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 $A$$n \times n$A i $i,\: j \in ([1, n] \cap \mathbb{Z})$

Przykłady takich matryc

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

Centrosymetryczna matryca o równej długości ( ):$4\times 4$

I nieparzystej długości ( ):$3\times 3$

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 $n$$n$ $n$$n$

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 $n$$n^2$

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]]

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/**/

Galaretka , ocena 2

⁼Ṛ
Ṛ⁼

Wypróbuj online!

Pobiera dane wejściowe jako spłaszczoną macierz kwadratową (wektor wielkości ).$n^2$

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 $i, j$$A_{i, j} = A_{n+1-i, n+1-j}$$j$$8$

$i' = (n + 1) - i$

$j' = n + 1 - (j - 8) + 8 = (n + 1) + (8 + 8) - j$

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

$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ą.

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!

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

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 ⌽)}

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!

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.

Pyt , rozmiar 1

₽

Wypróbuj online!

Sprawdza, czy dane wejściowe (w postaci połączonych wierszy) są palindromem.

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!

Ł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.

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)

Haskell, rozmiar 11 , 10 , 9 , 8

Pobiera dane wejściowe jako listę 2D! (Podziękowania dla Ørjan Johansen)

r= --r}-
 reverse
(==)<*> 
 r.map{-
-{pam.r 
 >*<)==(
esrever 
-}r-- =r

Python 2 , rozmiar 8

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

Wypróbuj online!

$n^2$

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.

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!

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 ² 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;
}

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
}

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!

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.

C (gcc) , 12 x 12

C(e,n,t,r)//
int*e;{for//
(r=t=0;e[t//
];r|=e[t]^//
e[~t+++n])//
;n=!!!!r;}//
//};r!!!!=n;
//)]n+++t~[e
//^]t[e=|r;]
//t[e;0=t=r(
//rof{;e*tni
//)r,t,n,e(C

Wypróbuj online!

> <>, 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!

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

Japt , rozmiar 2 (5 bajtów)

ê"
"ê

Spróbuj

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

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!

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)))

Clojure, rozmiar 9

#(= %(;;;
reverse;;
(map;;;;;
reverse;;
%)));)))%
;;esrever
;;;;;pam(
;;esrever
;;;(% =(#

Wypróbuj online!