定义

甲中心对称矩阵是正方形矩阵是对称的围绕其中心。更严格地说，如果对于任何满足以下关系，则大小为的矩阵是中心对称的： $A$$n \times n$$i,\: j \in ([1, n] \cap \mathbb{Z})$

此类矩阵的示例

这是这样的矩阵的对称性的图示（从上述Wikipedia文章中借来）：

偶数边长（ ×）的中心对称矩阵：$4\times 4$

还有一个奇数边长（）：$3\times 3$

任务和规格

给定大小为至少方阵，输出两个不同且一致的值之一，从而确定该矩阵是否为中心对称的。您可以假设矩阵将完全由正整数组成。$2$

但是，您的代码也必须是中心对称的。也就是说，它必须是由行组成的程序/函数（或等效项），每行在您的语言编码中包含个字节，并且必须满足上面给出的定义，但要使用字节而不是正整数。您提交的得分将是价值，具有较低是更好的。$n$$n$ $n$$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]]

JavaScript（ES6），大小12 11 9

所有版本返回假的中心对称或真正的非中心对称。

一维数组+长度，大小9（89字节）

以currying语法接受输入(length)(array)，其中array为一维。

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

在线尝试！

矩阵+宽度，大小11（131字节）

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

在线尝试！

有效载荷

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

果冻，得分2

⁼Ṛ
Ṛ⁼

在线尝试！

将输入作为平坦的方矩阵（大小为向量）。$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] 。但是，我们有一个问题：偏移量为。为了解决这个问题，使用了以下公式：$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$

没意见！

将输入作为一维列表

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

在线尝试！

$n= 10$

将输入作为二维矩阵

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

但是，我们现在有一些新问题。两者.和==反转时都是相同的，因此我们的反转行尝试重新定义运算符（<*>反转是>*<这样，所以我们在那方面很好。） 因为函数是函子.，<$>所以可以替换为。并且我们可以替换==为/=，这会否定我们的输出，但这仍然在规格范围内。现在我们有

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

现在，我们通过使所有物体成为中心对称和方形来完成此操作。

较短的一维版本以几乎相同的方式工作，只是因为不需要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

在这里尝试

说明

第一行反转输入和每一行，并检查是否剩下输入的副本。
在.q第二行退出程序，所以之后的一切，以及在q它之前，是一个空操作。

APL（Dyalog Unicode），得分7 6 5 4

完整程序。从stdin提示输入矩阵表达式。打印1或0，然后引发一致错误。没意见！

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

在线尝试！

⎕ 提示用于表达和评估它
, RAVEL（平整）
r← 将结果存储在r（对- [R avelled）

⌽r 镜像r
r≡ 隐式打印是否r与此相同

≡ 的深度r（给出1）
r⌽ 使用r旋转该
^{（这将总是导致RANK ERROR和退出，因为矩阵是不允许作为左参数⌽）}

Perl 6，大小9 8 7

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

在线尝试！

reverse是这里的瓶颈。我将其更改为技术上更长的时间，但可拆分的时间更多[*-1 X-^*]。好的，[R,]在看到Brad Gilbert对另一个问题的回答之后，我将其更改为。

展平的代码是{.flat eq [R,] .flat}。

编辑：该死，我意识到我什至不需要整理第一个列表，但是尝试将其缩短为6号大小的尝试失败了，只是一个字节太多而无法容纳...

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

:(

尽管如果将其视为一维数组，则很容易将其调整为6号大小。

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

在线尝试！

Wolfram语言（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]]==#&执行前三行。

此代码捕获名称中的函数f。

可悲的是，内置的PalindromeQ太长了。

PYT，尺寸1

₽

在线尝试！

检查输入（以级联行的形式）是否是回文。

Japt，大小9 4（11字节）

UªSê


êSªU

在线尝试！

进行一维输入，检查它是否是回文。如果需要的话，您可以在两行空白处填写一些ascii艺术。
旧的二维版本将输入旋转两次，并检查其是否与原始输入相等：

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

在线尝试！

3号果壳

Ṡ=↔
=↔=
↔=Ṡ

在线尝试！输入为一维列表。每行都定义一个函数，但仅调用第一行中的一个。

Ṡ=↔是回文测试，用于检查输入是否等于（=）其反向（↔）。

外壳尺寸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)

Haskell中，尺寸11，10，9，8

将输入作为2D列表！（提供给ØrjanJohansen）

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

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

在线尝试！

最后三行是实际程序，该程序将一维数组作为输入并检查其是否等于反向数组。真值：FALSE，假值：TRUE。

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

R + pryr，尺寸9

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



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

在线尝试！

C＃（.NET Core），得分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

在线尝试！

输入为一维数组，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>-

在线尝试！

以扁平矩阵作为输入的Lambda。对于中心对称返回true，否则返回false。

-1感谢Mr.XCoder，

开箱

->z{
  z == z.reverse
}

干净，大小9

感谢ØrjanJohansen！

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Â

输入为单个列表。
在线尝试。

我猜这不算数。

Â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将输入作为一维数组作为初始堆栈状态。如果矩阵是中心对称的，则退出，不输出；否则，返回错误（打印“东西闻到鱼腥味……”）。

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

我对这种输出格式并不完全满意，所以这是7号，输出1表示true，0表示false。

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

在线尝试！

Javascript ES6，大小8：

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

尺寸为7的Javascript ES6（有效吗？）：

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>

或将lambda保存到名为的变量中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，9号

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

在线尝试！