Définition

Une matrice centrosymétrique est une matrice carrée symétrique par rapport à son centre. Plus rigoureusement, une matrice de taille est centrosymétrique si, pour tout la relation suivante est satisfaite: n × n i $A$$n \times n$A i $i,\: j \in ([1, n] \cap \mathbb{Z})$

Exemples de telles matrices

Voici une illustration de la symétrie d’une matrice comme celle-ci (empruntée à l’article susmentionné de Wikipedia):

Une matrice centrosymétrique de longueur égale ( ):$4\times 4$

Et un côté impair ( $3\times 3$ ) un:

Tâche et spécifications

Avec une matrice carrée de taille au moins égale à , indiquez l'une des deux valeurs distinctes et cohérentes, en décidant si la matrice est centrosymétrique ou non. Vous pouvez supposer que la matrice sera entièrement composée d’entiers positifs.$2$

Cependant, votre code doit également être centrosymétrique. C'est-à-dire qu'il doit s'agir d'un programme / fonction (ou équivalents) composé de lignes, chacune contenant octets dans le codage de votre langue, et doit satisfaire à la définition donnée ci-dessus, mais avec des octets au lieu d'entiers positifs. Le score de votre soumission sera la valeur de , un inférieur étant meilleur.$n$$n$ $n$$n$

Vous pouvez entrer et fournir des sorties à l'aide de n'importe quelle méthode standard et dans n'importe quel format raisonnable, tout en prenant note que ces failles sont interdites par défaut. Vous pouvez (éventuellement) choisir de prendre la taille, , comme entrée également (à moins que vous preniez une entrée sous forme de liste 1D, auquel cas vous ne pouvez prendre que comme entrée supplémentaire).n $n$$n^2$

Cas de test

Vérité

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

Fausseté:

[[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), taille 12 11 9

Toutes les versions renvoient false pour centrosymmetric ou true pour non centrosymmetric.

Tableau à 1 dimension + longueur, taille 9 (89 octets)

Prend une entrée en syntaxe de currying (length)(array), où array est unidimensionnel.

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

Essayez-le en ligne!

Matrice + largeur, taille 11 (131 octets)

Prend la syntaxe de 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/**/

Essayez-le en ligne!

Charge utile

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

Récipient

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

Matrice seulement, taille 12 (155 octets)

C’est ma solution originale, qui calcule elle-même la largeur de la matrice.

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

Essayez-le en ligne!

Comment?

Nous avons besoin de quelques jetons critiques qui ne peuvent pas être séparés:

• some
• length
• )=>

Les sauts de ligne peuvent être insérés presque n'importe où ailleurs.

Le code de charge utile déroulée se lit comme suit:

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

et est enveloppé dans la structure suivante:

/**/CODE////*/

qui, une fois inversé, devient un commentaire de bloc valide:

/*////EDOC/**/

Gelée , score 2

⁼Ṛ
Ṛ⁼

Essayez-le en ligne!

Prise en entrée sous forme de matrice carrée aplatie (vecteur de taille ).$n^2$

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

Essayez-le en ligne!

Entrée:, n suivi des éléments du tableau, tous séparés par des espaces. REMARQUE: vous devrez peut-être utiliser un interprète différent si vous avez une entrée assez grande.

Je suis sûr qu'il y a une meilleure façon de faire ça, je voulais juste l'essayer à Befunge. La partie de code actuelle est la moitié supérieure.

Comment?

Le code est divisé en deux sections principales, l' initialisation et la vérification .

Initialisation:

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

Cette section du code écrit la matrice d'entrée juste en dessous du code sous forme de caractères ASCII. Cette section et la section suivante utilisent les trois cellules en haut à gauche du code en tant que données. Ils sont stockés sous n, i, j.

Vérification:

                     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$

Les autres parties du code sont des ordures non lues pour le rendre centrosymétrique.

$n = 8$

Sans commentaires!

Prend les entrées sous forme de liste 1D

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

Essayez-le en ligne!

$n= 10$

Prend les entrées sous forme de matrice 2D

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

Essayez-le en ligne!

Merci à potato44 pour toute son aide dans le chat. Et Lynn pour avoir joué au golf.

Explication

L’idée générale ici est simple, nous avons concatla liste et la comparons à l’inverse. Cependant, puisque nous voulons être centrosymétriques, nous devons agir avec prudence. D'abord nous écrivons le code comme nous le ferions normalement:

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

Pour que nos lignes inverses soient également valides, nous avons besoin que le côté gauche de nos équations ressemble à une définition de fonction tacnoc.)esrever>*<)==((.

La première étape pour résoudre ce problème consiste à éliminer les parenthèses.

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

Cependant, nous avons maintenant de nouveaux problèmes. Les deux fonctions .et ==lorsqu'elles sont inversées sont identiques, alors nos lignes inversées tentent de redéfinir les opérateurs ( <*>inversées, de >*<sorte que tout va bien pour nous). .peut être remplacé par <$>puisque les fonctions sont des foncteurs. Et nous pouvons remplacer ==par /=, ce qui annule notre production, mais cela reste dans les spécifications. Maintenant nous avons

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

Afin de réduire notre longueur de ligne nous alias concatet reverse.

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

Maintenant, nous venons de terminer ceci en rendant tout ce qui est centrosymétrique et carré.

La version 1-D plus courte fonctionne à peu près de la même manière, sauf qu'il n'est pas nécessaire de concatsauvegarder deux lignes en la supprimant.

Python 2 , taille 10 (109 octets)

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

Essayez-le en ligne!

Précédent Python 2 , taille 14 (209 octets)

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

Essayez-le en ligne!

Pyth, taille 6 (41 octets)

q_M_QQ
q.q   


   q.q
QQ_M_q

Essayez-le ici

Explication

La première ligne inverse l'entrée et chaque ligne, et vérifie s'il nous reste une copie de l'entrée.
Le .qdans la deuxième ligne quitte le programme, donc tout après, ainsi que le qprécédent, est un no-op.

APL (Dyalog Unicode) , score 7 6 5 4

Programme complet. Invite l'expression de la matrice à partir de stdin. Imprime un 1 ou un 0, puis jette une erreur cohérente. Sans commentaires!

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

Essayez-le en ligne!

⎕ invite pour l' expression et l' évaluer
, RAVEL (aplatissent) , il
r← stocke le résultat dans r(pour r avelled)

⌽r miroir r
r≡ imprimer implicitement si rest identique à celle

≡ profondeur de r(donne 1) à
r⌽ utiliser rpour faire pivoter cela
^{(cela causera toujours un RANK ERRORet quitter car une matrice n'est pas autorisée comme argument de gauche ⌽)}

Perl 6 , taille 9 8 7

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

Essayez-le en ligne!

reverseest le goulot d'étranglement ici. Je l'ai changé pour le plus technique, mais beaucoup plus séparable [*-1 X-^*]. D'accord, j'ai changé pour [R,]après avoir vu la réponse de Brad Gilbert à une autre question.

Le code aplati est {.flat eq [R,] .flat}.

Edit: Zut, je me suis rendu compte que je n'ai même pas besoin d'aplatir la première liste, mais les tentatives pour la réduire à une taille 6 ont échoué avec juste un octet de trop pour tenir ...

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

:(

Cependant, si nous le prenons comme un tableau unidimensionnel, il est facile de l’adapter à une taille 6.

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

Essayez-le en ligne!

Wolfram Language (Mathematica) (REPL uniquement), taille 8 (71 octets)

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

Retourne Truepour une entrée centrosymétrique, et Falsesinon

Dans Mathematica REPL, les lignes contenant des erreurs de syntaxe sont ignorées (une barre rouge épaisse apparaît sur le côté de l'écran). Ici, seules les trois premières lignes f=#[[c=-1;;1;;-1,c]]==#&, sont exécutées.

Ce code capture la fonction dans le nom f.

Malheureusement, le préréglage PalindromeQest trop long.

Pyt , taille 1

₽

Essayez-le en ligne!

Vérifie si l'entrée (sous la forme de lignes concaténées) est un palindrome.

Japt , taille 9 4 (11 octets)

UªSê


êSªU

Essayez-le en ligne!

Prend une entrée unidimensionnelle, vérifie s'il s'agit d'un palindrome. Si vous le souhaitez, vous pouvez remplir les deux lignes vides d'un dessin ascii.
L'ancienne version à deux dimensions fait pivoter l'entrée deux fois et vérifie si elle correspond à l'original:

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

Essayez-le en ligne!

Coque , taille 3

Ṡ=↔
=↔=
↔=Ṡ

Essayez-le en ligne! Entrée en tant que 1D-List. Chaque ligne définit une fonction, mais seule celle de la première ligne est appelée.

Ṡ=↔ est un test de palindrome qui vérifie si l’entrée est égale à (= ) son inverse ( ↔).

Décortiquer , taille 4

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

Essayez-le en ligne! Pour une entrée en tant que matrice 2D, nous concaténons ( Σ) la liste de listes avant de vérifier qu’il s’agit d’un palindrome.

MATL , score 4

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

L'entrée a le format [1 2; 2 1], en utilisant ;comme séparateur de lignes.

La sortie se fait via STDERR ( autorisé par défaut):

• Pour une entrée centrosymétrique, une erreur d'erreur cohérente est générée. Avec les versions actuelles de Linux et d’Octave dans TIO, la sortie STDERR suivante est générée (sans tenir compte des dernières lignes commençant parReal 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'erreur peut être différente selon les versions de Linux et Octave, mais sera cohérente d'une entrée à l'autre.

• Pour une entrée non centrosymétrique, aucune erreur n'est générée et la sortie STDERR sur TIO est

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

Essayez-le en ligne!Ou vérifiez tous les cas de test:

• Centrosymétrique: 1 , 2 , 3 , 4 , 5 , 6 .
• Non centrosymétrique: 1 , 2 , 3 , 4 , 5 , 6 .

Vérifiez que le programme est centrosymétrique.

Explication

%est le symbole de commentaire, ce qui a pour effet d'ignorer le reste de la ligne. Les nouvelles lignes sont également ignorées. Donc, le code est juste

t,!P]=?P!,t

qui fait ce qui suit:

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, taille 11 , 10 , 9 , 8

Prend l'entrée sous forme de liste 2D! (Crédit: Ørjan Johansen)

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

Python 2 , taille 8

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

Essayez-le en ligne!

Prend en entrée une liste 1D de lignes concaténées (de longueur) $n^2$) et les sorties via le code de sortie (0 pour les entrées symétriques, 1 sinon).

La liste est simplement vérifiée pour être un palindrome. Si c'est le cas, la chaîne de comparaison a[::-1]!=a<_échoue à l' !=étape et court-circuite; sinon, la variable inconnue _est évaluée et bloque le programme.

R , taille 9

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

Essayez-le en ligne!

Les trois dernières lignes sont le programme qui prend un tableau 1D en entrée et vérifie s'il est égal à son inverse. Valeur de vérité: FAUX, Valeur de faux: VRAIE.

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

R + pryr, taille 9

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



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

Essayez-le en ligne!

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

Essayez-le en ligne!

Prend en entrée un tableau 1D et n ^{2 une} longueur; renvoie falsepour centrosymmetric et truepour non-centrosymmetric. Cette version utilise System.Linqmais je ne sais pas comment l'adapter à la soumission de code en raison des exigences particulières du défi. Code déroulé:

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

Voici ma soumission précédente qui n'utilise pas LINQ:

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

Essayez-le en ligne!

Code déroulé:

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

Ruby , score 9 8 8

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

Essayez-le en ligne!

Un lambda prenant une matrice aplatie en entrée. Renvoie true pour centrosymmetric, false sinon.

-1 merci à Mr.XCoder,

Déballé:

->z{
  z == z.reverse
}

Propre , taille 9

Merci à Ørjan Johansen !

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

Essayez-le en ligne!

Propre , taille 10

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

Essayez-le en ligne!

05AB1E , taille 3 (11 octets )

ÂQq

qQÂ

Entrée sous forme de liste unique.
Essayez-le en ligne.

Je suppose que celui-ci ne compte pas ..; p

ÂQ
qâ

Entrée sous forme de liste unique.
Essayez-le en ligne.

Explication:

         # 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

Quelques alternatives de taille 3 (11 octets ):

R€R
QqQ
R€R

Matrice en entrée.
Essayez-le en ligne.

RQ 
 q  
 QR

Liste unique en entrée.
Essayez-le en ligne.

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

Essayez-le en ligne!

> <>, Taille 6

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

Essayez-le en ligne!

(Il s'avère que c'est une douleur qui passe plusieurs valeurs à -v in tio)

L'entrée est considérée comme un tableau unidimensionnel comme état de pile initial avec -v. Sortie sans sortie si la matrice est centrosymétrique, sortie avec une erreur (affiche "Quelque chose sent le poisson ...") sinon.

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

Je n'étais pas entièrement satisfait de ce format de sortie. Voici donc un format de taille 7 qui affiche 1 pour vrai et 0 pour faux.

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

Essayez-le en ligne!

Stax , n = 3

$cr
=q=
rc$

Exécuter et déboguer

Explication:

$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 est le meilleur possible car il me faut au moins trois commandes: Copier, inverser et comparer

Stax , n = 4

Mrxr
M=qX
Xq=M
rxrM

Exécuter et déboguer

Explication:

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 , taille 2 (5 octets)

ê"
"ê

L'essayer

Java 10, taille 13 (181 octets)

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

Essayez-le en ligne.

Inspiré par la réponse C # de Charlie Charlie .

Explication golfée:

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

Prend une liste de int et n comme arguments. Retourne n comme valeur de vérité, 0 comme faux.

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

Essayez-le en ligne!

Javascript ES6, taille 8:

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

Javascript ES6, taille 7 (est-ce valide?):

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

Tester:

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

ou avec lambda enregistré dans la variable nommée 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, Taille 9

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

Essayez-le en ligne!