Khiếm khuyết

Một ma trận đối xứng là một ma trận vuông đối xứng với tâm của nó. Nghiêm ngặt hơn, một ma trận có kích thước là đối xứng nếu, đối với mọi mối quan hệ sau đây được thỏa mãn: n × n i $A$$n \times n$Một i $i,\: j \in ([1, n] \cap \mathbb{Z})$

Ví dụ về các ma trận như vậy

Dưới đây là một minh họa về tính đối xứng của các ma trận như thế này (mượn từ bài viết Wikipedia đã nói ở trên):

Một ma trận đối xứng tâm có chiều dài bằng nhau ( ):$4\times 4$

Và một chiều dài lẻ ( ) một:$3\times 3$

Nhiệm vụ và thông số kỹ thuật

Cho một ma trận vuông có kích thước ít nhất là , xuất ra một trong hai giá trị riêng biệt và nhất quán, quyết định xem ma trận có đối xứng hay không. Bạn có thể giả định rằng ma trận sẽ bao gồm hoàn toàn các số nguyên dương.$2$

Tuy nhiên, mã của bạn cũng phải là đối xứng. Nghĩa là, nó phải là một chương trình / hàm (hoặc tương đương) bao gồm dòng, mỗi dòng chứa byte trong mã hóa ngôn ngữ của bạn và phải đáp ứng định nghĩa được đưa ra ở trên, nhưng với byte thay vì số nguyên dương. Điểm của bài nộp của bạn sẽ là giá trị của , với thấp hơn sẽ tốt hơn.n n $n$$n$ $n$$n$

Bạn có thể lấy đầu vào và cung cấp đầu ra thông qua bất kỳ phương thức tiêu chuẩn nào và ở bất kỳ định dạng hợp lý nào, trong khi lưu ý rằng các lỗ hổng này bị cấm theo mặc định. Bạn có thể (tùy chọn) chọn lấy kích thước, , làm đầu vào (trừ khi bạn lấy đầu vào làm danh sách 1D, trong trường hợp đó bạn chỉ có thể lấy làm đầu vào bổ sung).n $n$$n^2$

Các trường hợp thử nghiệm

Sự thật:

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

Giả mạo:

[[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), kích thước 12 11 9

Tất cả các phiên bản trả về false cho centrosymmetric hoặc true cho non-centrosymmetric.

Mảng 1 chiều + chiều dài, kích thước 9 (89 byte)

Đưa đầu vào theo cú pháp currying (length)(array), trong đó mảng là 1 chiều.

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

Hãy thử trực tuyến!

Ma trận + chiều rộng, kích thước 11 (131 byte)

Đưa đầu vào theo cú pháp currying (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/**/

Hãy thử trực tuyến!

Khối hàng

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

Thùng đựng hàng

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

Chỉ ma trận, kích thước 12 (155 byte)

Đây là giải pháp ban đầu của tôi, nó tự tính toán độ rộng của ma trận.

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

Hãy thử trực tuyến!

Làm sao?

Chúng tôi cần một số mã thông báo quan trọng không thể phân tách:

• some
• length
• )=>

Nguồn cấp dữ liệu có thể được chèn vào hầu hết mọi nơi khác.

Mã tải trọng không được kiểm soát đọc là:

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

và được bọc bên trong cấu trúc sau:

/**/CODE////*/

mà, một khi đã đảo ngược, trở thành một nhận xét khối hợp lệ:

/*////EDOC/**/

Thạch , điểm 2

⁼Ṛ
Ṛ⁼

Hãy thử trực tuyến!

Đưa đầu vào dưới dạng ma trận vuông dẹt (vectơ có kích thước ).$n^2$

Befunge-93 , cỡ 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:&   

Hãy thử trực tuyến!

Đầu vào : n , theo sau là các phần tử của mảng, tất cả được phân tách bằng dấu cách. LƯU Ý: bạn có thể cần sử dụng một trình thông dịch khác nếu bạn có đầu vào đủ lớn.

Tôi chắc chắn có một cách tốt hơn để làm điều này, tôi chỉ muốn thử điều này trong Befunge. Phần mã thực tế là nửa trên.

Làm sao?

Mã được chia thành hai phần chính, khởi tạo và xác minh .

Khởi tạo:

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

Phần này của mã viết ma trận đầu vào ngay bên dưới mã dưới dạng các ký tự ASCII. Cả phần này và phần tiếp theo đều sử dụng ba ô ở phía trên bên trái của mã làm dữ liệu. Chúng được lưu trữ như n, i, j.

Xác minh:

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

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

Các phần khác của mã là rác chưa đọc để làm cho nó đối xứng.

$n = 8$

Miễn bình luận!

Đưa đầu vào dưới dạng danh sách 1-D

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

Hãy thử trực tuyến!

$n= 10$

Đưa đầu vào dưới dạng ma trận 2 chiều

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

Hãy thử trực tuyến!

Cảm ơn khoai tây44 vì tất cả sự giúp đỡ của họ trong trò chuyện. Và Lynn cho chơi golf một hàng.

Giải trình

Ý tưởng chung ở đây là một ý tưởng đơn giản, chúng tôi concatliệt kê và so sánh nó với nó ngược lại. Tuy nhiên vì chúng tôi muốn được đối xứng, chúng tôi phải bước cẩn thận. Đầu tiên chúng ta viết mã như bình thường:

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

Bây giờ để các đường ngược của chúng ta cũng là Haskell hợp lệ, chúng ta cần phía bên trái của phương trình của chúng ta trông giống như một định nghĩa hàm tacnoc.)esrever>*<)==((không.

Bước đầu tiên để khắc phục điều này là xử lý dấu ngoặc đơn.

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

Tuy nhiên chúng tôi có một số vấn đề mới bây giờ. Cả hai .và ==khi đảo ngược là như nhau, vì vậy các dòng đảo ngược của chúng tôi cố gắng xác định lại các toán tử ( <*>đảo ngược là >*<vì vậy chúng tôi ổn ở mặt trước đó). .có thể được thay thế bằng <$>vì các chức năng là functor. Và chúng ta có thể thay thế ==bằng /=, điều này phủ nhận đầu ra của chúng ta, nhưng điều đó vẫn nằm trong thông số kỹ thuật. Bây giờ chúng tôi có

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

Để cắt giảm chiều dài dòng của chúng tôi, chúng tôi bí danh concatvà reverse.

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

Bây giờ chúng tôi chỉ hoàn thành điều này bằng cách làm cho mọi thứ đối xứng và vuông.

Phiên bản 1-D ngắn hơn hoạt động theo cùng một cách trừ khi không cần concatchúng ta có thể lưu hai dòng bằng cách xóa nó.

Python 2 , kích thước 10 (109 byte)

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

Hãy thử trực tuyến!

Trước Python 2 , kích thước 14 (209 bytes)

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

Hãy thử trực tuyến!

Bình thường, kích thước 6 (41 byte)

q_M_QQ
q.q   


   q.q
QQ_M_q

Hãy thử nó ở đây

Giải trình

Dòng đầu tiên đảo ngược đầu vào và từng hàng và kiểm tra xem chúng ta có còn lại một bản sao của đầu vào không.
Dòng .qthứ hai thoát khỏi chương trình, vì vậy mọi thứ sau đó, cũng như qtrước đó, là không có.

APL (Dyalog Unicode) , điểm 7 6 5 4

Chương trình đầy đủ. Nhắc nhở cho biểu thức ma trận từ stdin. In 1 hoặc 0 và sau đó đưa ra một lỗi nhất quán. Miễn bình luận!

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

Hãy thử trực tuyến!

⎕ nhắc nhở biểu hiện và đánh giá nó
, ravel (flatten) nó
r← lưu kết quả trong r(cho r avelling)

⌽r Gương r
r≡ in ngầm cho dù rlà giống hệt với điều đó

≡ độ sâu của r(cho 1)
r⌽ sử dụng rđể xoay vòng đó
^{(điều này sẽ luôn gây ra a RANK ERRORvà thoát vì ma trận không được phép làm đối số trái ⌽)}

Perl 6 , cỡ 9 8 7

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

Hãy thử trực tuyến!

reverselà nút cổ chai ở đây. Tôi đã thay đổi nó thành kỹ thuật lâu hơn, nhưng dễ chia tách hơn nhiều [*-1 X-^*]. Được rồi, tôi đã đổi nó thành [R,]sau khi thấy câu trả lời của Brad Gilbert cho một câu hỏi khác.

Mã dẹt là {.flat eq [R,] .flat}.

Chỉnh sửa: Chết tiệt, tôi đã nhận ra rằng tôi thậm chí không cần phải làm phẳng danh sách đầu tiên, nhưng những nỗ lực rút ngắn nó xuống kích thước 6 đã thất bại chỉ với một byte quá nhiều để phù hợp với ...

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

:

Mặc dù nếu chúng ta coi nó là một mảng một chiều, thật dễ dàng để điều chỉnh nó ở kích thước 6.

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) (chỉ REPL), kích thước 8 (71 byte)

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

Trả về Trueđầu vào đối xứng, và Falsenếu không.

Trên Mathicala REPL, các dòng có lỗi cú pháp được bỏ qua (với một thanh màu đỏ dày xuất hiện ở bên cạnh màn hình). Ở đây, chỉ có ba dòng đầu tiên f=#[[c=-1;;1;;-1,c]]==#&, được thực thi.

Mã này nắm bắt chức năng trong tên f.

Đáng buồn thay, tích hợp PalindromeQquá dài.

Pyt , cỡ 1

₽

Hãy thử trực tuyến!

Kiểm tra xem đầu vào (ở dạng hàng nối) có phải là một bảng màu không.

Japt , kích thước 9 4 (11 byte)

UªSê


êSªU

Hãy thử trực tuyến!

Đưa đầu vào một chiều, kiểm tra xem nó có phải là một bảng màu không. Nếu bạn muốn, bạn có thể điền vào hai dòng trống cho một số nghệ thuật ascii.
Phiên bản hai chiều cũ, xoay đầu vào hai lần và kiểm tra xem nó có bằng với bản gốc không:

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

Hãy thử trực tuyến!

Trấu , cỡ 3

Ṡ=↔
=↔=
↔=Ṡ

Hãy thử trực tuyến! Nhập dưới dạng 1D-List. Mỗi dòng định nghĩa một hàm, nhưng chỉ một dòng trên dòng đầu tiên được gọi.

Ṡ=↔là một kiểm tra palindrom để kiểm tra xem đầu vào có bằng ( =) đảo ngược ( ↔) của nó không .

Trấu , cỡ 4

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

Hãy thử trực tuyến! Đối với đầu vào dưới dạng ma trận 2D, chúng tôi ghép ( Σ) danh sách các danh sách trước khi kiểm tra xem đó có phải là một bảng màu không.

MATL , điểm 4

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

Đầu vào có định dạng [1 2; 2 1], sử dụng ;như dấu phân cách hàng.

Đầu ra là thông qua STDERR ( được cho phép theo mặc định):

• Đối với đầu vào trung tâm đối xứng, một lỗi lỗi nhất quán được tạo ra. Với các phiên bản Linux và Octave hiện tại trong TIO, đầu ra STDERR sau đây được tạo ra (bỏ qua các dòng cuối cùng bắt đầu bằng 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...
  

  Lỗi có thể khác nhau tùy thuộc vào phiên bản Linux và Octave, nhưng sẽ thống nhất giữa các đầu vào.

• Đối với đầu vào không đối xứng, không có lỗi nào được tạo ra và đầu ra STDERR trên TIO là

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

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm:

• Trung tâm đối xứng: 1 , 2 , 3 , 4 , 5 , 6 .
• Không đối xứng: 1 , 2 , 3 , 4 , 5 , 6 .

Kiểm tra xem chương trình có đối xứng không.

Giải trình

%là ký hiệu nhận xét, khiến phần còn lại của dòng o bị bỏ qua. Dòng mới cũng bị bỏ qua. Vì vậy, mã chỉ là

t,!P]=?P!,t

mà làm như sau:

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, kích thước 11 , 10 , 9 , 8

Đưa đầu vào dưới dạng danh sách 2D! (Tín dụng cho Ørjan Johansen)

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

Con trăn 2 , cỡ 8

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

Hãy thử trực tuyến!

$n^2$

Danh sách được kiểm tra đơn giản là một bảng màu. Nếu có, chuỗi so sánh a[::-1]!=a<_thất bại ở !=bước và ngắn mạch; mặt khác, biến không xác định _được đánh giá, làm hỏng chương trình.

R , cỡ 9

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

Hãy thử trực tuyến!

Ba dòng cuối cùng là chương trình thực tế lấy mảng 1D làm đầu vào và kiểm tra xem nó có bằng ngược lại không. Giá trị thật: FALSE, Giá trị giả: TRUE.

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

R + pryr, cỡ 9

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



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

Hãy thử trực tuyến!

C # (.NET Core) , điểm 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

Hãy thử trực tuyến!

Lấy đầu vào là mảng 1D và n ² là chiều dài; trả về falsecho đối xứng và truekhông đối xứng. Phiên bản này sử dụng System.Linqnhưng tôi không biết làm thế nào để phù hợp với nó trong việc gửi mã do các yêu cầu cụ thể của thử thách. Mã chưa được kiểm soát:

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

Sau đây là lần gửi trước của tôi không sử dụng LINQ:

C # (.NET Core) , điểm 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

Hãy thử trực tuyến!

Mã chưa được kiểm soát:

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

Ruby , điểm 9 8

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

Hãy thử trực tuyến!

Một lambda lấy một ma trận dẹt làm đầu vào. Trả về true cho centrosymmetric, false khác.

-1 cảm ơn Mr.XCoder,

Giải nén:

->z{
  z == z.reverse
}

Sạch , cỡ 9

Cảm ơn Ørjan Johansen !

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

Hãy thử trực tuyến!

Sạch sẽ , cỡ 10

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

Hãy thử trực tuyến!

05AB1E , kích thước 3 (11 byte )

ÂQq

qQÂ

Nhập dưới dạng một danh sách.
Hãy thử trực tuyến.

Tôi đoán cái này không được tính ..; p

ÂQ
qâ

Nhập dưới dạng một danh sách.
Hãy thử trực tuyến.

Giải trình:

         # 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

Một số lựa chọn thay thế kích thước 3 (11 byte ):

R€R
QqQ
R€R

Ma trận làm đầu vào.
Hãy thử trực tuyến.

RQ 
 q  
 QR

Danh sách duy nhất là đầu vào.
Hãy thử trực tuyến.

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

Hãy thử trực tuyến!

> <>, Kích thước 6

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

Hãy thử trực tuyến!

(Hóa ra đó là một nỗi đau truyền nhiều giá trị cho -v trong tio)

Đầu vào được lấy dưới dạng mảng một chiều làm trạng thái ngăn xếp ban đầu với -v. Thoát ra không có đầu ra nếu ma trận là đối xứng, thoát ra có lỗi (in "Cái gì đó có mùi tanh ...") nếu không.

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

Tôi không hoàn toàn hài lòng với định dạng đầu ra này, vì vậy đây là kích thước 7, đầu ra 1 là đúng và 0 là sai.

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

Hãy thử trực tuyến!

Căng , n = 3

$cr
=q=
rc$

Chạy và gỡ lỗi nó

Giải trình:

$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 là tốt nhất có thể vì tôi cần ít nhất ba lệnh: Sao chép, đảo ngược và so sánh

Căng , n = 4

Mrxr
M=qX
Xq=M
rxrM

Chạy và gỡ lỗi nó

Giải trình:

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 , kích thước 2 (5 byte)

ê"
"ê

Thử nó

Java 10, kích thước 13 (181 byte)

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

Hãy thử trực tuyến.

Lấy cảm hứng từ câu trả lời C # của @Charlie .

Giải thích về gôn:

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) , điểm 11

Lấy một danh sách int và n làm đối số. Trả về n là giá trị trung thực, 0 là sai.

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

Hãy thử trực tuyến!

Javascript ES6, kích thước 8:

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

Javascript ES6, kích thước 7 (có hợp lệ không?):

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

Kiểm tra:

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

hoặc với lambda được lưu vào biến có tên 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, Size 9

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

Hãy thử trực tuyến!