Czy macierz jest centrosymetryczna… podobnie jak kod?


37

Definicja

Centrosymmetric matryca jest kwadratem matrycy , która jest symetryczna względem jego środka. Bardziej rygorystycznie, macierz o rozmiarze jest centrosymetryczna, jeśli dla dowolnego spełniona jest następująca zależność: n × n i ,An×nA i ,i,j([1,n]Z)

Ai,j=An+1i,n+1j

Przykłady takich matryc

Oto ilustracja symetrii takich macierzy (zapożyczona z wyżej wspomnianego artykułu w Wikipedii):

Centrosymetryczna matryca 5 na 5 zilustrowana w naprawdę ładny sposób

Centrosymetryczna matryca o równej długości ( ):4×4

(1234567887654321)

I nieparzystej długości ( ):3×3

(123565321)

Zadanie i specyfikacje

Biorąc pod uwagę kwadratową macierz wielkości co najmniej , wyprowadzaj jedną z dwóch różnych i spójnych wartości, decydując, czy macierz jest centrosymetryczna, czy nie. Możesz założyć, że macierz będzie składała się wyłącznie z dodatnich liczb całkowitych.2

Jednak twój kod musi być również centrosymetryczny. Oznacza to, że musi to być program / funkcja (lub odpowiednik) składający się z wierszy, z których każdy zawiera bajtów w kodowaniu języka, i musi spełniać powyższą definicję, ale z bajtami zamiast dodatnich liczb całkowitych. Wynik twojego zgłoszenia będzie wynosił , przy czym niższy będzie lepszy.n n nnn nn

Możesz pobierać dane wejściowe i generować dane wyjściowe dowolną standardową metodą w dowolnym rozsądnym formacie, zwracając uwagę, że te luki są domyślnie zabronione. Możesz (opcjonalnie) wybrać także rozmiar , jako dane wejściowe (chyba że weźmiesz dane jako listę 1D, w którym to przypadku możesz wziąć jako dodatkowe dane wejściowe).n 2nn2

Przypadki testowe

Prawda:

[[1, 2], [2, 1]]
[[1, 2, 3], [5, 6, 5], [3, 2, 1]]
[[10, 5, 30], [2, 6, 2], [30, 5, 10]]
[[100, 100, 100], [100, 50, 100], [100, 100, 100]]
[[1, 2, 3, 4], [5, 6, 7, 8], [8, 7, 6, 5], [4, 3, 2, 1]]
[[3, 4, 5, 6, 7], [5, 6, 7, 8, 9], [3, 2, 10, 2, 3], [9, 8, 7, 6, 5], [7, 6, 5, 4, 3]]

Falsy:

[[1, 2], [1, 2]]
[[1, 2, 10], [5, 6, 5], [11, 2, 1]]
[[14, 5, 32], [2, 6, 2], [30, 5, 16]]
[[19, 19, 19], [40, 50, 4], [19, 19, 19]]
[[1, 2, 20, 4], [7, 6, 7, 8], [8, 7, 6, 6], [3, 3, 2, 1]]
[[3, 4, 5, 6, 7], [5, 6, 7, 8, 9], [4, 5, 10, 4, 5], [5, 6, 7, 8, 9], [3, 4, 5, 6, 7]]

1
Hmm, to wciąż wygląda dość ciężko dla języków nie golfowych, ponieważ łamie nawiasy i nawiasy kwadratowe bez komentarzy. Naiwnym podejściem byłoby kończenie każdego wiersza znakiem komentarza (takim jak Python #), aby cała dolna część kodu była komentarzem.
JungHwan Min

@JungHwanMin W tym konkretnym przypadku Python #nie będzie działał, ponieważ komentarze poprzedzone #są tylko wstawiane: P
Mr.

1

6
Chyba po prostu zacznę się różnić, ponieważ ograniczenia źródła bardzo zmieniają wszystko, a kryterium wygranej jest inne. Moim zdaniem różnice te są wystarczające. Do tego są inne techniki (w wielu językach krótsze - np. Mathematica), które można zastosować zamiast spłaszczania + sprawdzania palindromu.
Pan Xcoder,

1
@WW W skrócie, aby uprościć wyzwanie i uniknąć wszelkiego rodzaju niechcianych skrzynek. Poza tym utrzymanie kwadratu jest dla mnie bardziej intuicyjne.
Pan Xcoder,

Odpowiedzi:


21

JavaScript (ES6), rozmiar 12 11 9

Wszystkie wersje zwracają wartość false dla centrosymmetric lub true dla niecentrosymmetric.


Tablica 1-wymiarowa + długość, rozmiar 9 (89 bajtów)

Pobiera dane wejściowe w składni curry (length)(array), gdzie tablica jest jednowymiarowa.

w=>a=> //
a.some //
(v=>v- //
a[--w])//
/////////
//)]w--[a
// -v>=v(
// emos.a
// >=a>=w

Wypróbuj online!


Matryca + szerokość, rozmiar 11 (131 bajtów)

Pobiera dane w składni curry (width)(matrix).

/**/w=>a=>a
.some(r=>r.
some(v=>v-a
[y][w-++x],
x=!y--),y=w
);'*/'/*';)
w=y,)--y!=x
,]x++-w[]y[
a-v>=v(emos
.r>=r(emos.
a>=a>=w/**/

Wypróbuj online!

Ładowność

w => a => a.some(r => r.some(v => v - a[y][w - ++x], x = !y--), y = w)

Pojemnik

/**/CODE;'*/'/*';EDOC/**/

Tylko macierz, rozmiar 12 (155 bajtów)

To jest moje oryginalne rozwiązanie, które samo oblicza szerokość matrycy.

/**/a=>a[w=a
.length-1,s=
'some']((r,y
)=>r[s]((v,x
)=>v-a[w-y][
w-x]))////*/
/*////))]x-w
[]y-w[a-v>=)
x,v((]s[r>=)
y,r((]'emos'
=s,1-htgnel.
a=w[a>=a/**/

Wypróbuj online!

W jaki sposób?

Potrzebujemy kilku krytycznych tokenów, których nie można podzielić:

  • some
  • length
  • )=>

Kanały liniowe można wstawiać prawie wszędzie.

Rozwinięty kod ładunku brzmi:

a => a[w = a.length - 1, s = 'some']((r, y) => r[s]((v, x) => v - a[w - y][w - x]))

i jest zawinięty w następującą strukturę:

/**/CODE////*/

który po odwróceniu staje się poprawnym komentarzem do bloku:

/*////EDOC/**/


15

Befunge-93 , rozmiar 24

   &:00p110p920p::*:v   
vp01:+1g01-1pg02g01&_v#<
>00g`#v_>:           1$^
v2p011<  v:g00p029p01< @
>0g1+20p^>*:#v_1# .#<@ .
v+1g00gg02g01<$ >1+10pv0
>:10g-\88++20g -g-     |
vg02p011_v#`g00g01-1  <1
>1+20p   >:   ^ ^      <
                        
                        
                        
                        
                        
                        
<      ^ ^   :>   p02+1>
1<  1-10g00g`#v_110p20gv
|     -g- g02++88\-g01:>
0vp01+1> $<10g20gg00g1+v
. @<#. #1_v#:*>^p02+1g0>
@ <10p920p00g:v  <110p2v
^$1           :>_v#`g00>
<#v_&10g20gp1-10g1+:10pv
   v:*::p029p011p00:&   

Wypróbuj online!

Dane wejściowe:, n po których następują elementy tablicy, wszystkie oddzielone spacjami. UWAGA: może być konieczne użycie innego tłumacza, jeśli masz wystarczająco duży wkład.

Jestem pewien, że jest na to lepszy sposób, chciałem tylko wypróbować to w Befunge. Rzeczywista część kodu to górna połowa.

W jaki sposób?

Kod podzielony jest na dwie główne sekcje: inicjalizację i weryfikację .

Inicjalizacja:

   &:00p110p920p::*:v   
vp01:+1g01-1pg02g01&_v#<
>00g`#v_>:           1$^

Ta sekcja kodu zapisuje macierz wprowadzania bezpośrednio pod kodem jako znaki ASCII. Zarówno ta, jak i następna sekcja wykorzystują trzy komórki w lewym górnym rogu kodu jako dane. Są przechowywane jako n, i, j.

Weryfikacja:

                     v 
                     1
v2p011<  v:g00p029p01< @
>0g1+20p^>*:#v_1# .#<@ .
v+1g00gg02g01<$ >1+10pv0
>:10g-\88++20g -g-     |
vg02p011_v#`g00g01-1  <1
>1+20p   >:   ^ ^      <

W tej sekcji sprawdza się każdy indeks [1-indeksowany] pod warunku . Mamy jednak problem: mamy przesunięcie o . Aby to naprawić, stosuje się następujące formuły:A i , j = A n + 1 - i , n + 1 - j j 8i,jAi,j=An+1i,n+1jj8

i=(n+1)i

j=n+1(j8)+8=(n+1)+(8+8)j

Pozostałe części kodu to nieprzeczytane śmieci, dzięki czemu są one centrosymetryczne.


15

n=8

Bez komentarza!

Pobiera dane wejściowe jako listę 1-D

s a b=  
    a/=b
f =s<*> 
 reverse
esrever 
 >*<s= f
b=/a     
  =b a s

Wypróbuj online!

n=10

Pobiera dane wejściowe jako matrycę 2-D

r =reverse
s a b=a/=b
f   =s<*>r
c  =concat
g =  f<$>c
c>$<f  = g
tacnoc=  c
r>*<s=   f
b=/a=b a s
esrever= r

Wypróbuj online!

Podziękowania dla potato44 za całą ich pomoc na czacie. I Lynn za grę w golfa z rzędu.

Wyjaśnienie

Ogólny pomysł tutaj jest prosty, my concatlistę i porównajmy to do tyłu. Ponieważ jednak chcemy być centrosymetryczni, musimy ostrożnie podążać. Najpierw piszemy kod w normalny sposób:

g=((==)<*>reverse).concat

Teraz, aby nasze odwrotne linie również były poprawne, Haskell, potrzebujemy lewej strony naszych równań, aby wyglądały, jakby definicja funkcji tacnoc.)esrever>*<)==((nie.

Pierwszym krokiem do rozwiązania tego jest usunięcie nawiasów.

s a b=a==b
f=s<*>reverse
g=f.concat

Mamy jednak teraz kilka nowych problemów. Oba .i ==po odwróceniu są takie same, więc nasze odwrócone linie próbują na nowo zdefiniować operatory ( <*>odwrócone jest >*<więc w porządku, jeśli chodzi o ten front). .można zastąpić, <$>ponieważ funkcje są funktorami. I możemy wymienić ==się /=, co neguje nasze wyjście, ale to jest wciąż w specyfikacji. Teraz mamy

s a b=a/=b
f=s<*>reverse
g=f<$>concat

Aby skrócić naszą długość linii, mamy alias concati reverse.

r=reverse
s a b=a/=b
f=s<*>r
c=concat
g=f<$>c

Teraz kończymy to, czyniąc wszystko centrosymetrycznym i kwadratowym.

Krótsza wersja 1-D działa w ten sam sposób, z wyjątkiem tego, że nie concatmusimy zapisywać dwóch linii, usuwając ją.


Co powiesz na to dla n = 10?
Lynn

@Lynn Thanks! W mojej głowie <$>było też odwrotnie <$>.
Wheat Wizard

9

Python 2 , rozmiar 10 (109 bajtów)

def f(a):#
 return(a#
==[r[::-1#
]for r in#
a[::-1]])#
#)]]1-::[a
#ni r rof]
#1-::[r[==
#a(nruter 
#:)a(f fed

Wypróbuj online!

Poprzedni Python 2 , rozmiar 14 (209 bajtów)

lambda a:all(#
a[i][j]==a[-i#
-1][-j-1]for #
i in range(  #
len(a))for j #
in range(len(#
a)))         #
#         )))a
#(nel(egnar ni
# j rof))a(nel
#  (egnar ni i
# rof]1-j-[]1-
#i-[a==]j[]i[a
#(lla:a adbmal

Wypróbuj online!


1
Nie jestem pewien, czy wystarczyłoby to do rearanżacji, ale FYI -i-1i -j-1może po prostu być ~ii~j
Pan Xcoder

@Pan. Xcoder: Trochę się z tym bawiłem, ale to nie zmienia wyniku.
Chas Brown,

Działa również w python3.6, ale może nie być optymalny.
SIGSTACKFAULT,

8

Pyth, rozmiar 6 (41 bajtów)

q_M_QQ
q.q   


   q.q
QQ_M_q

Wypróbuj tutaj

Wyjaśnienie

Pierwszy wiersz odwraca dane wejściowe i każdy wiersz i sprawdza, czy pozostała nam kopia danych wejściowych. W drugiej linii zamyka program, więc wszystko po tym, jak również przed nim, to nie-op.
.qq


8

APL (Dyalog Unicode) , wynik 7 6 5 4

Pełny program Monity o wyrażenie macierzy ze standardowego wejścia. Drukuje 1 lub 0, a następnie zgłasza spójny błąd. Bez komentarza!

r←,⎕
r≡⌽r
r⌽≡r
⎕,←r

Wypróbuj online!

 monituj o wyrażenie i oceń go
, ravel (spłaszcz)
r← zapisz wynik r(dla r avelled)

⌽rr
r≡ kopia  lustrzana domyślnie drukuje, czy rjest identyczna

 głębokość r(daje 1)
r⌽ użycie rdo obrócenia tego
 (to zawsze spowoduje a RANK ERRORi wyjście, ponieważ macierz nie jest dozwolona jako lewy argument )


7

Perl 6 , rozmiar 9 8 7

{.flat#
#}talf.
#  ],R[
eq # qe
[R,]  #
.flat}#
#talf.{

Wypróbuj online!

reversejest tutaj wąskie gardło. Zmieniłem to na technicznie dłuższe, ale o wiele bardziej podzielne [*-1 X-^*]. Okej, zmieniłem na [R,]po obejrzeniu odpowiedzi Brada Gilberta na inne pytanie.

Spłaszczony kod to {.flat eq [R,] .flat}.

Edycja: Cholera, zdałem sobie sprawę, że nawet nie muszę spłaszczać pierwszej listy, ale próby skrócenia jej do rozmiaru 6 nie powiodły się z zaledwie jednym bajtem za dużo, by zmieścić ...

{@_#}_@
eq#<<|
[R,] #
# ],R[
|<<#qe
@_}#_@{

:(

Chociaż, jeśli weźmiemy to za jednowymiarowy układ, łatwo jest zmieścić go w rozmiarze 6.

{$_# }
eq #_$
[R,] #
# ],R[
$_# qe
} #_${

Wypróbuj online!


6

Wolfram Language (Mathematica) (tylko REPL), rozmiar 8 (71 bajtów)

f=#[[c=-
1;;1;;-1
,c]]==#&
(*      
      *(
&#==]]c,
1-;;1;;1
-=c[[#=f

Zwraca Truedane wejściowe centrosymetryczne i Falseinne.

W Mathematica REPL linie z błędami składniowymi są ignorowane (z grubym czerwonym paskiem pojawiającym się z boku ekranu). Tutaj f=#[[c=-1;;1;;-1,c]]==#&wykonywane są tylko trzy pierwsze wiersze .

Ten kod przechwytuje funkcję w nazwie f.

Niestety wbudowany PalindromeQjest za długi.



5

Japt , rozmiar 9 4 (11 bajtów)

UªSê


êSªU

Wypróbuj online!

Pobiera jednowymiarowe dane wejściowe, sprawdza, czy jest to palindrom. Jeśli chcesz, możesz wypełnić dwie puste linie dla sztuki ascii.
Stara dwuwymiarowa wersja dwukrotnie obraca wejście i sprawdza, czy jest ono równe oryginałowi:

W=U  I
Wz2;II
Vc)eUc
cUe)cV
II;2zW
I  U=W

Wypróbuj online!


1
Miły! Wydaje mi się, że mam 6 i próbuję też pokonać niechętnych do współpracy 4, ale oba są znacznie bardziej trywialne niż to.
Kudłaty

@Shaggy Udało mi się uzyskać to samo rozwiązanie do sześciu po nadaniu mu świeżego wyglądu, cztery byłyby bardzo imponujące.
Nit

Biorąc pod uwagę, że dane wejściowe mogą (teraz) być tablicą jednowymiarową, można to zrobić z wynikiem 2.
Shaggy

@Shaggy Nie jestem pewien, czy widzę jak, źródłem musi być NxN.
Nit


4

Łuska , rozmiar 3

Ṡ=↔
=↔=
↔=Ṡ

Wypróbuj online! Wprowadź jako listę 1D. Każda linia definiuje funkcję, ale wywoływana jest tylko ta w pierwszym wierszu.

Ṡ=↔to test palindromu, który sprawdza, czy dane wejściowe są równe ( =) jego odwrotności ( ).


Łuska , rozmiar 4

Ṡ=↔Σ
Σ↔=Ṡ
Ṡ=↔Σ
Σ↔=Ṡ

Wypróbuj online! W przypadku danych wejściowych w postaci macierzy 2D konkatenujemy ( Σ) listę list przed sprawdzeniem, czy jest to palindrom.


3

MATL , wynik 4

t,!P
]=%?
?%=]
P!,t

Dane wejściowe mają format [1 2; 2 1]wykorzystujący ;jako separator wierszy.

Wyjście odbywa się za pośrednictwem STDERR ( domyślnie dozwolone ):

  • W przypadku wprowadzania centrosymetrycznego generowany jest stały błąd błędu. Przy obecnych wersjach Linux i Octave w TIO generowane są następujące dane wyjściowe STDERR (bez względu na ostatnie wiersze, które zaczynają się od Real time: ...):

    octave: X11 DISPLAY environment variable not set
    octave: disabling GUI features
    Python 2.7.15 (default, May 16 2018, 17:50:09) 
    [GCC 8.1.1 20180502 (Red Hat 8.1.1-1)] on linux2
    Type "help", "copyright", "credits" or "license" for more information.
    >>> >>> /usr/include/c++/8/bits/basic_string.h:1048: std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::reference std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::operator[](std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::size_type) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<char>; std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::reference = char&; std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::size_type = long unsigned int]: Assertion '__pos <= size()' failed.
    panic: Aborted -- stopping myself...
    

    Błąd może być różny w zależności od wersji Linux i Octave, ale będzie spójny we wszystkich wejściach.

  • W przypadku danych niecentrosymetrycznych nie występuje błąd, a wyjście STDERR w TIO wynosi

    octave: X11 DISPLAY environment variable not set
    octave: disabling GUI features
    Python 2.7.15 (default, May 16 2018, 17:50:09) 
    [GCC 8.1.1 20180502 (Red Hat 8.1.1-1)] on linux2
    Type "help", "copyright", "credits" or "license" for more information.
    >>> >>> 
    

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe:

  • Centrosymetryczny: 1 , 2 , 3 , 4 , 5 , 6 .
  • Niecentrosymetryczny: 1 , 2 , 3 , 4 , 5 , 6 .

Sprawdź , czy program jest centrosymetryczny.

Wyjaśnienie

%to symbol komentarza, który powoduje ignorowanie reszty wiersza. Nowe linie są również ignorowane. Więc kod jest po prostu

t,!P]=?P!,t

który wykonuje następujące czynności:

t       % Input, implicit. Duplicate
,       % Do twice
  !     %   Transpose
  P     %   Flip vertically
]       % End
=       % Compare element-wise
?       % If all comparisons gave true
  P     %   Implicit input. Transpose. Actually, since there is no more input, an
        %   error is prand the program exits. The rest of the code is not executed, 
        %   and will be described in parentheses
  !     %   (Transpose)
  ,     %   (Do twice)
    t   %     (Duplicate)
        %   (End, implicit)
        % (End, implicit)


2

Python 2 , rozmiar 8

i=input#
a=i()###
a[::-1##
]!=a<_##
##_<a=!]
##1-::[a
###)(i=a
#tupni=i

Wypróbuj online!

n2

Lista jest po prostu sprawdzana jako palindrom. Jeśli tak, łańcuch porównawczy a[::-1]!=a<_zawodzi na !=etapie i powoduje zwarcie; w przeciwnym razie nieznana zmienna _zostanie poddana ocenie, powodując awarię programu.


2

R , rozmiar 9

   #)x-))
#(nacs-<x
#(ver(yna
#       #
#       #
#       #
any(rev(#
x<-scan(#
))-x)#   

Wypróbuj online!

Ostatnie trzy wiersze to rzeczywisty program, który pobiera tablicę 1D jako dane wejściowe i sprawdza, czy jest ona równa odwrotności. Prawda: FALSE, Wartość Falsy: PRAWDA.

any(rev(x<-scan())-x)

R + pryr, rozmiar 9

pryr::f(#
any(rev(#
x)-x))#  



  #))x-)x
#(ver(yna
#(f::ryrp

Wypróbuj online!


2

C # (.NET Core) , wynik 13 11 10

l=>a=>a.//
Where((e//
,i)=>e!=//
a[l-i-1]//
).Any()///
///()ynA.)
//]1-i-l[a
//=!e>=)i,
//e((erehW
//.a>=a>=l

Wypróbuj online!

Pobiera dane wejściowe jako tablicę 1D, a n 2 jako długość; zwraca falsedla centrosymetrycznego i truedla niecentrosymetrycznego. Ta wersja używa, System.Linqale nie wiem, jak dopasować ją do kodu, ze względu na szczególne wymagania wyzwania. Kod rozwinięty:

l => a => a.Where((e,i) => e != a[l-i-1]).Any()

Oto moje poprzednie zgłoszenie, które nie korzysta z LINQ:

C # (.NET Core) , wynik 16 15 13

l=>a=>{/////*
var r=1<2;for
(int i=0;i<l;
)r&=a[i]==a[l
-i++-1];
return r;}
     /*/
   };r nruter
     ;]1-++i-
l[a==]i[a=&r)
;l<i;0=i tni(
rof;2<1=r rav
*/////{>=a>=l

Wypróbuj online!

Kod rozwinięty:

l => a =>
{
    var r = 1<2;
    for (int i = 0; i < l;)
        r &= a[i] == a[l-i++-1];
    return r;
}

Jeśli zmienisz intna var(a więc również tnina rav), drugie przesłanie działa również w JavaScript.
Zacharý

2

Ruby , zdobądź 9 8

->z{z==#
z.######
reverse#
}#######
#######}
#esrever
######.z
#==z{z>-

Wypróbuj online!

Lambda przyjmująca spłaszczoną macierz jako dane wejściowe. Zwraca true dla centrosymmetric, false w przeciwnym razie.

-1 dzięki Mr.XCoder,

Rozpakowane:

->z{
  z == z.reverse
}

2

Czysty , rozmiar 9

Dzięki Ørjan Johansen !

import //
 StdEnv//
r=reverse
?m=m==r//
    m    
//r==m=m?
esrever=r
//vnEdtS 
// tropmi

Wypróbuj online!

Czysty , rozmiar 10

import/*//
*/StdEnv//
r =reverse
?m      //
 =m==r m//
//m r==m= 
//      m?
esrever= r
//vnEdtS/*
//*/tropmi

Wypróbuj online!


1
To nie z powodu nowej linii, działa z wcięciem. 9 linii
Ørjan Johansen

@ ØrjanJohansen Nie mogę uwierzyć, że zapomniałem, że można je wciąć. Dzięki!
Οurous

Nie ma za co, a po opublikowaniu redagowałem środkową linię, po prostu musi być m.
Ørjan Johansen

@ ØrjanJohansen Zaktualizowałem odpowiedź, aby to odzwierciedlić. Również w ten sposób wygląda naprawdę elegancko.
Οurous

2

05AB1E , rozmiar 3 (11 bajtów )

ÂQq

qQÂ

Wprowadź jako pojedynczą listę.
Wypróbuj online.

Myślę, że to się nie liczy ...; str

ÂQ
qâ

Wprowadź jako pojedynczą listę.
Wypróbuj online.

Wyjaśnienie:

         # Bifurcate this list (short for DR: Duplicate & Reverse copy)
 Q        # Check if the input-list and the reversed list are equal
  q       # Terminate the program
   qQâ    # No-ops

Niektóre alternatywy rozmiaru 3 (11 bajtów ):

R€R
QqQ
R€R

Matryca jako dane wejściowe.
Wypróbuj online.

RQ 
 q  
 QR

Pojedyncza lista jako dane wejściowe.
Wypróbuj online.



1

> <>, Rozmiar 6

!/l2(\
s\?\ ?
/{=/ ;
: /={/
? \?\s
\(2l/!

Wypróbuj online!

(Okazuje się, że ból powoduje wielokrotne przekazywanie wartości do -v in tio)

Dane wejściowe są traktowane jako jednowymiarowa tablica jako początkowy stan stosu z -v. Wychodzi bez wyjścia, jeśli matryca jest centrosymetryczna, wychodzi z błędem (wypisuje „Coś pachnie rybim ...”), jeśli nie.

l2(    Checks if the length of the stack is less than 2
?;     Exits cleanly if so

{=     Checks if the first and last elements are equal
?\s    Causes an error ('s' is not a valid instruction) if not

Nie byłem do końca zadowolony z tego formatu wyjściowego, więc oto rozmiar 7, który daje 1 dla wartości true i 0 dla wartości false.

!/l2(\\
 ?   ?0
 =;n1/n
;{   {;
n/1n;= 
0?   ? 
\\(2l/!

Wypróbuj online!


Dobra robota! > <> może być fajnym językiem do pracy, chyba że jest to złożony program, to jest ból.
mbomb007

1
jeśli zamienisz prawdziwe i fałszywe wartości, możesz sprowadzić je do 4 z{-?;
Jo King

1

Stax , n = 3

$cr
=q=
rc$

Uruchom i debuguj

Wyjaśnienie:

$cr =q= rc$ Full program, implicit input
$           Flatten
 cr         Copy and reverse
    =       Compare to original
     q      Print result
      =     Silently error because there is only one item on stack
        rc$ Not executed

3 jest najlepszym możliwym, ponieważ potrzebuję co najmniej trzech poleceń: Kopiuj, odwróć i porównaj

Stax , n = 4

Mrxr
M=qX
Xq=M
rxrM

Uruchom i debuguj

Wyjaśnienie:

Mrxr M=qX Xq=M rxrM Full program, implicit input
Mr                  Transpose and reverse
  x                 Push input again
   r M              Reverse and transpose
      =             Compare
       qX Xq        Print result twice and save to X
            =       Silently error because there is only one item on stack
             M rxrM Not executed


1

Java 10, rozmiar 13 (181 bajtów)

a->{var r///*
=1>0;for(int 
l=a.length,i=
0;i<l;)r&=a[i
]==a[l-++i]; 
return r;}   
     /*/     
   };r nruter
 ;]i++-l[a==]
i[a=&r);l<i;0
=i,htgnel.a=l
 tni(rof;0>1=
*///r rav{>-a

Wypróbuj online.

Zainspirowany odpowiedzią C # @Charlie .

Wyjaśnienie w golfa:

a->{var r=1>0;for(int l=a.length,i=0;i<l;)r&=a[i]==a[l-++i];return r;}

a->{                    //  Method with byte-array parameter and boolean return-type
  var r=1>0;            //  Result-boolean, starting at true
  for(int l=a.length,   //  The length of the input-array
      i=0;i<l;)         //  Loop `i` in the range [0, length)
    r&=                 //   Bitwise-AND the result-boolean with:
       a[i]             //    Whether the current item
           ==a[l-++i];  //    equals the opposite item
  return r;}            //  Return the result

1

C (gcc) , wynik 11

Pobiera listę liczb int i n jako argumentów. Zwraca n jako wartość prawdy, 0 jako fałsz.

/*//};n=l;k
--*==++l*=*
n);l>k;n*n+
l=k(rof{;l*
tni)n,l(f;k
*/*/////*/*
k;f(l,n)int
*l;{for(k=l
+n*n;k>l;)n
*=*l++==*--
k;l=n;}//*/

Wypróbuj online!


0

JavaScript ES6, rozmiar 8:

/***/a=>
""+a==a.
reverse(
)/////*/
/*/////)
(esrever
.a==a+""
>=a/***/

JavaScript ES6, rozmiar 7 (czy jest poprawny?):

a=>""+a
==a.//=
reverse
`     `
esrever
=//.a==
a+"">=a

Test:

<script>
f=

a=>""+a
==a.//=
reverse
`     `
esrever
=//.a==
a+"">=a
</script>

<script>
console.log([
  [1, 2, 2, 1],
  [1, 2, 3, 5, 6, 5, 3, 2, 1],
  [10, 5, 30, 2, 6, 2, 30, 5, 10],
  [100, 100, 100, 100, 50, 100, 100, 100, 100],
  [1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1],
  [3, 4, 5, 6, 7, 5, 6, 7, 8, 9, 3, 2, 10, 2, 3, 9, 8, 7, 6, 5, 7, 6, 5, 4, 3],
].every(f))

console.log([
  [1, 2, 1, 2],
  [1, 2, 10, 5, 6, 5, 11, 2, 1],
  [14, 5, 32, 2, 6, 2, 30, 5, 16],
  [19, 19, 19, 40, 50, 4, 19, 19, 19],
  [1, 2, 20, 4, 7, 6, 7, 8, 8, 7, 6, 6, 3, 3, 2, 1],
  [3, 4, 5, 6, 7, 5, 6, 7, 8, 9, 4, 5, 10, 4, 5, 5, 6, 7, 8, 9, 3, 4, 5, 6, 7],
].every(x=>!f(x)))
</script>

lub z zapisem lambda w zmiennej o nazwie a:

a=

a=>""+a
==a.//=
reverse
`     `
esrever
=//.a==
a+"">=a

console.log([
  [1, 2, 2, 1],
  [1, 2, 3, 5, 6, 5, 3, 2, 1],
  [10, 5, 30, 2, 6, 2, 30, 5, 10],
  [100, 100, 100, 100, 50, 100, 100, 100, 100],
  [1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1],
  [3, 4, 5, 6, 7, 5, 6, 7, 8, 9, 3, 2, 10, 2, 3, 9, 8, 7, 6, 5, 7, 6, 5, 4, 3],
].every(a))

console.log([
  [1, 2, 1, 2],
  [1, 2, 10, 5, 6, 5, 11, 2, 1],
  [14, 5, 32, 2, 6, 2, 30, 5, 16],
  [19, 19, 19, 40, 50, 4, 19, 19, 19],
  [1, 2, 20, 4, 7, 6, 7, 8, 8, 7, 6, 6, 3, 3, 2, 1],
  [3, 4, 5, 6, 7, 5, 6, 7, 8, 9, 4, 5, 10, 4, 5, 5, 6, 7, 8, 9, 3, 4, 5, 6, 7],
].every(x=>!a(x)))


Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.