정의

중심 대칭 행렬은 정사각형 행렬 의 중심에 대해 대칭이다. 더 엄격하게, 크기가 행렬 는 대해 다음 관계가 만족되는 경우 중심 대칭 이다 : n × n i $A$$n \times n$A i $i,\: j \in ([1, n] \cap \mathbb{Z})$

그러한 행렬의 예

다음은 이와 같은 행렬의 대칭에 대한 그림입니다 (위의 Wikipedia 기사에서 차용).

짝수-길이 ( ) 중심 대칭 행렬 :$4\times 4$

홀수 측 길이 ( )$3\times 3$

작업 및 사양

크기가 이상인 정사각 행렬이 주어지면 행렬이 중심 대칭인지 아닌지를 결정하는 두 개의 고유하고 일관된 값 중 하나를 출력합니다. 행렬이 양의 정수로만 구성되어 있다고 가정 할 수 있습니다.$2$

그러나 코드는 중심 대칭이어야합니다. 즉, 그것은 구성된 프로그램 / 기능 (또는 등가물)이어야 함유가 각각의 라인 바이트 대신 양의 정수의 바이트를 원하는 언어의 인코딩, 및 상기 주어진 정의를 만족해야한다. 제출 점수는 값이 되고 , 이 낮을 수록 좋습니다.n n $n$$n$ $n$$n$

이러한 허점 은 기본적으로 금지되어 있음을 유의하면서 모든 표준 방법 과 합리적인 형식으로 입력을 받고 출력을 제공 할 수 있습니다 . (선택적으로) 크기 을 입력으로 선택할 수도 있습니다 ( 1D 목록으로 입력을받지 않는 한 추가 입력으로 만 사용할 수 있음 ).n $n$$n^2$

테스트 사례

진실한 :

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

거짓 :

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

자바 스크립트 (ES6), 크기 12 11 9

모든 버전 은 중심 대칭의 경우 false 를, 중심 중심 이 아닌 경우 true 를 반환 합니다.

1 차원 배열 + 길이, 크기 9 (89 바이트)

태닝 구문 입력을 받아 (length)(array), 어레이는 1 차원이다.

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

온라인으로 사용해보십시오!

행렬 + 너비, 크기 11 (131 바이트)

카레 구문으로 입력을 (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/**/

온라인으로 사용해보십시오!

유효 탑재량

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

컨테이너

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

행렬 만, 크기 12 (155 바이트)

이것은 독자적인 솔루션으로 행렬의 너비를 자체적으로 계산합니다.

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

온라인으로 사용해보십시오!

어떻게?

분할 할 수없는 몇 가지 중요한 토큰이 필요합니다.

• some
• length
• )=>

줄 바꿈은 거의 다른 곳에 삽입 할 수 있습니다.

언롤 된 페이로드 코드는 다음과 같습니다.

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

다음 구조 안에 싸여 있습니다.

/**/CODE////*/

일단 뒤집 으면 유효한 블록 주석이됩니다.

/*////EDOC/**/

젤리 ,이 점수

⁼Ṛ
Ṛ⁼

온라인으로 사용해보십시오!

입력을 평평한 사각형 행렬 (크기 벡터)로 취합니다 .$n^2$

Befunge-93 , 사이즈 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:&   

온라인으로 사용해보십시오!

입력 : n 뒤에 배열 요소가 모두 공백으로 구분됩니다. 참고 : 입력이 충분히 큰 경우 다른 통역사를 사용해야 할 수도 있습니다.

더 좋은 방법이 있다고 확신합니다. Befunge에서 시도하고 싶었습니다. 실제 코드 부분은 상위 절반입니다.

어떻게?

코드는 초기화 와 검증 의 두 가지 주요 섹션으로 나뉩니다 .

초기화 :

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

이 코드 섹션에서는 코드 바로 아래에 입력 행렬을 ASCII 문자로 씁니다. 이 섹션과 다음 섹션 모두 코드 왼쪽 상단에있는 세 개의 셀을 데이터로 사용합니다. 로 저장됩니다 n, i, j.

확인:

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

이 섹션 에서는 조건에 대해 모든 인덱스 [1-indexed]를 검사합니다 . 그러나 우리는 문제가 있습니다 : 오프셋이 입니다. 이를 해결하기 위해 다음 공식이 사용됩니다.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$

코드의 다른 부분은 읽지 않은 쓰레기이므로 중심 대칭으로 만듭니다.

하스켈 ,$n = 8$

코멘트가 없습니다!

1 차원 목록으로 입력을받습니다.

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

온라인으로 사용해보십시오!

$n= 10$

2 차원 행렬로 입력을받습니다.

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

온라인으로 사용해보십시오!

채팅에 도움 을 주신 potato44 에게 감사합니다 . 그리고 행에서 골프를 타기 위한 Lynn .

설명

여기에 일반적인 아이디어는 단순한 아이디어입니다. 우리 concat는 목록을 뒤집어 비교합니다. 그러나 우리는 중심 대칭 적이기를 원하기 때문에 조심스럽게 밟아야합니다. 먼저 평소와 같이 코드를 작성합니다.

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

이제 역행이 유효한 Haskell이 되려면 함수 정의 tacnoc.)esrever>*<)==((가 그렇지 않은 것처럼 보이는 방정식의 왼쪽이 필요합니다 .

이를 해결하는 첫 번째 단계는 괄호를 처리하는 것입니다.

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

그러나 지금 우리에게는 새로운 문제가 있습니다. 모두 .와 ==반전 할 때 우리의 역전 라인 (연산자 재정의를 시도하므로, 동일 <*>입니다 반전을 >*<우리가 전면에 잘 그래서). 함수는 functors이므로 .로 대체 할 수 있습니다 <$>. 그리고 우리는 대체 할 수 ==와 /=우리의 출력을 부정하지만, 그 사양 내에서 여전히이다. 이제 우리는

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

위해서는 우리의 선 길이 우리 별칭을 자릅니다 concat및 reverse.

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

이제 우리는 모든 것을 중심 대칭과 사각형으로 만들어서 마무리합니다.

더 짧은 1D 버전은 concat두 줄을 제거하여 저장할 필요가 없기 때문에 거의 같은 방식으로 작동 합니다.

Python 2 , 크기 10 (109 바이트)

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

온라인으로 사용해보십시오!

이전 Python 2 , 크기 14 (209 바이트)

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

온라인으로 사용해보십시오!

Pyth, 크기 6 (41 바이트)

q_M_QQ
q.q   


   q.q
QQ_M_q

여기 사용해보십시오

설명

첫 번째 줄은 입력과 각 행을 뒤집고 입력 사본이 남아 있는지 확인합니다. 두 번째 라인은 그 후 모든뿐만 아니라, 수 있도록, 프로그램을 종료 그것을하기 전에 어떤 조합이 없습니다.
.qq

APL (Dyalog Unicode) , 점수 7 6 5 4

전체 프로그램. stdin에서 행렬 표현식을 프롬프트합니다. 1 또는 0을 인쇄 한 다음 일관된 오류가 발생합니다. 코멘트가 없습니다!

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

온라인으로 사용해보십시오!

⎕ 표현을위한 신속하고이 평가
, 는 (평평) 라벨
r← 에 결과를 저장 r(대한 연구가 avelled)

⌽r 거울 이 그것과 동일한 r
r≡ 지 암시 적으로 인쇄r

≡ 심도 r(1 번 제공)를
r⌽ 사용 r하여 회전
^{( RANK ERROR매개 변수가에 대한 왼쪽 인수로 허용되지 않기 때문에 항상 a 를 종료하고 종료합니다 ⌽)}

펄 6 , 사이즈 9 8 7

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

온라인으로 사용해보십시오!

reverse병목 현상이 여기에 있습니다. 나는 기술적으로 더 길었지만 훨씬 더 분할 가능하도록 변경했습니다 [*-1 X-^*]. 좋아, 나는 또 다른 질문에 대한 브래드 길버트의 대답 을 [R,]본 후에 그것을 바꿨다 .

병합 된 코드는 {.flat eq [R,] .flat}입니다.

편집 : 젠장, 나는 첫 번째 목록을 평평하게 할 필요 조차 없다는 것을 깨달았 지만 크기를 6으로 줄이려는 시도는 1 바이트가 너무 많아 실패했습니다 ...

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

:(

1 차원 배열로 가져가더라도 크기 6에 맞추기가 쉽습니다.

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

온라인으로 사용해보십시오!

Wolfram Language (Mathematica) (REPL 만 해당), 크기 8 (71 바이트)

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

True중심 대칭 입력을 반환 합니다 False.

Mathematica REPL에서 구문 오류가있는 줄은 무시됩니다 (화면 측면에 두꺼운 빨간색 막대가 나타남). 여기에서는 처음 세 줄만 f=#[[c=-1;;1;;-1,c]]==#&실행됩니다.

이 코드는 name의 함수를 캡처합니다 f.

안타깝게도 내장 기능 PalindromeQ이 너무 깁니다.

Pyt , 크기 1

₽

온라인으로 사용해보십시오!

입력 (연결된 행 형식)이 회문인지 확인합니다.

Japt , 크기 9 4 (11 바이트)

UªSê


êSªU

온라인으로 사용해보십시오!

1 차원 입력을 받아 회문인지 확인합니다. 원하는 경우 일부 아트 아트에 대해 두 개의 빈 줄을 채울 수 있습니다.
이전의 2 차원 버전은 입력을 두 번 회전하고 원래와 같은지 확인합니다.

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

온라인으로 사용해보십시오!

껍질 , 크기 3

Ṡ=↔
=↔=
↔=Ṡ

온라인으로 사용해보십시오! 1D-List로 입력하십시오. 각 줄은 함수를 정의하지만 첫 번째 줄의 함수 만 호출됩니다.

Ṡ=↔입력이 =반전 ( ↔)과 같은지 ( ) 확인하는 회문 테스트입니다 .

껍질 , 크기 4

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

온라인으로 사용해보십시오! 2D 행렬로 입력하기 위해, 우리 Σ는 회문인지 확인하기 전에 목록의 목록을 연결합니다 ( ).

MATL , 4 점

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

입력의 형식 은 행 구분 기호로 [1 2; 2 1]사용 ;됩니다.

출력은 STDERR을 통해 이루어 집니다 (기본적으로 허용됨 ).

• 중심 대칭 입력의 경우 일관된 오류 오류가 발생합니다. TIO의 현재 Linux 및 Octave 버전을 사용하면 다음과 같은 STDERR 출력이 생성됩니다 (로 시작하는 최종 행은 무시 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...
  

  오류는 Linux 및 Octave 버전에 따라 다를 수 있지만 입력간에 일관성이 있습니다.

• 비 중심 대칭 입력의 경우 오류가 발생하지 않으며 TIO의 STDERR 출력은

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

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오.

• 중심 대칭 : 1 , 2 , 3 , 4 , 5 , 6 .
• 비 중심 : 1 , 2 , 3 , 4 , 5 , 6 .

프로그램이 중심 대칭인지 확인하십시오 .

설명

%주석 기호이며, 나머지 행 o는 무시됩니다. 개행도 무시됩니다. 그래서 코드는

t,!P]=?P!,t

다음을 수행합니다.

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)

하스켈, 크기 11 , 10 , 9 , 8

입력을 2D 목록으로 가져옵니다! (Ørjan Johansen의 크레딧)

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

파이썬 2 , 크기 8

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

온라인으로 사용해보십시오!

$n^2$

목록은 단순히 회문으로 확인됩니다. 만약 그렇다면, 비교 체인 a[::-1]!=a<_은 !=단계 에서 실패 하고 단락된다; 그렇지 않으면 알 수없는 변수 _가 평가되어 프로그램이 중단됩니다.

R 사이즈 9

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

온라인으로 사용해보십시오!

마지막 세 줄은 1D 배열을 입력으로 사용하고 그 반대와 같은지 확인하는 실제 프로그램입니다. 진실 가치 : 거짓, 거짓 가치 : 참.

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

R + pryr, 크기 9

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



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

온라인으로 사용해보십시오!

C # (. NET 코어) , 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

온라인으로 사용해보십시오!

입력을 1D 배열로, n ² 를 길이로 사용합니다. false중심 대칭 및 true비 중심 대칭에 대한 반환 값 . 이 버전은 사용 System.Linq하지만 도전 과제의 특정 요구 사항으로 인해 코드 제출에 맞추는 방법을 모르겠습니다. 언롤 코드 :

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

다음은 LINQ를 사용하지 않는 이전 제출물입니다.

C # (.NET Core) , 점수 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

온라인으로 사용해보십시오!

언롤 코드 :

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

루비 , 9 8 점

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

온라인으로 사용해보십시오!

평탄화 된 행렬을 입력으로 취하는 람다. 중심 대칭에 대해서는 true를, 그렇지 않으면 false를 반환합니다.

XCoder 덕분에 -1

포장 풀기 :

->z{
  z == z.reverse
}

깨끗 하고 크기 9

Ørjan Johansen 에게 감사합니다 !

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

온라인으로 사용해보십시오!

깨끗 하고 크기 10

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

온라인으로 사용해보십시오!

05AB1E , 크기 3 (11 바이트 )

ÂQq

qQÂ

단일 목록으로 입력하십시오.
온라인으로 사용해보십시오.

나는 이것 하나는 계산되지 않는다고 생각한다 ..; p

ÂQ
qâ

단일 목록으로 입력하십시오.
온라인으로 사용해보십시오.

설명:

         # 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

일부 크기 3 (11 바이트 ) 대안 :

R€R
QqQ
R€R

입력으로서의 행렬.
온라인으로 사용해보십시오.

RQ 
 q  
 QR

입력 된 단일 목록.
온라인으로 사용해보십시오.

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

온라인으로 사용해보십시오!

> <>, 크기 6

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

온라인으로 사용해보십시오!

(tio에서 여러 값을 -v로 전달하는 것이 고통 스럽습니다)

입력은 -v를 사용하여 초기 스택 상태로 1 차원 배열로 간주됩니다. 행렬이 중심 대칭 인 경우 출력없이 종료되고, 그렇지 않으면 오류로 종료됩니다 ( "뭔가 냄새가 나는 물고기 ..."로 표시됨).

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

나는이 출력 형식에 완전히 만족하지 않았으므로 여기에 1을 true로, 0을 false로 출력하는 크기 7이 있습니다.

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

온라인으로 사용해보십시오!

Stax , n = 3

$cr
=q=
rc$

실행 및 디버깅

설명:

$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은 적어도 세 가지 명령이 필요하기 때문에 가장 좋습니다 : 복사, 역전 및 비교

Stax , n = 4

Mrxr
M=qX
Xq=M
rxrM

실행 및 디버깅

설명:

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 , 크기 2 (5 바이트)

ê"
"ê

시도 해봐

Java 10, 크기 13 (181 바이트)

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

온라인으로 사용해보십시오.

@Charlie 의 C # 답변에서 영감을 얻었습니다 .

골프 설명 :

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) , 11 점

int 및 n 목록을 인수로 사용합니다. n을 진솔한 값으로, 0을 거짓으로 반환합니다.

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

온라인으로 사용해보십시오!

자바 스크립트 ES6, 크기 8 :

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

Javascript ES6, 크기 7 (유효합니까?) :

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

테스트:

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

또는 람다가 변수 이름으로 저장된 경우 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)))

클로저, 크기 9

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

온라인으로 사용해보십시오!