Definição

Uma matriz centrosimétrica é uma matriz quadrada simétrica em relação ao seu centro. Mais rigorosamente, uma matriz de tamanho n × n é centrossimétrica se, para qualquer$A$$n \times n$ a seguinte relação é satisfeita: A i $i,\: j \in ([1, n] \cap \mathbb{Z})$

Exemplos de tais matrizes

Aqui está uma ilustração da simetria de matrizes como essas (emprestadas do artigo da Wikipedia acima mencionado):

Matriz centrossimétrica de comprimento lateral ( ):$4\times 4$

E um comprimento de lado ímpar ( ):$3\times 3$

Tarefa e especificações

Dada uma matriz quadrada de tamanho pelo menos , produza um de dois valores distintos e consistentes, decidindo se a matriz é centrossimétrica ou não. Você pode assumir que a matriz consistirá inteiramente de números inteiros positivos.$2$

No entanto, seu código também deve ser centrossimétrico. Ou seja, ele deve ser um programa / função (ou equivalentes) que consiste em linhas, cada uma contendo n bytes na codificação de seu idioma, e deve atender à definição fornecida acima, mas com bytes em vez de números inteiros positivos. A pontuação do seu envio será o valor de n , com um n menor sendo melhor.$n$$n$ $n$$n$

Você pode obter entrada e fornecer saída através de qualquer método padrão e em qualquer formato razoável, observando que essas brechas são proibidas por padrão. Você pode (opcionalmente) escolher o tamanho, , como entrada também (a menos que você aceite a entrada como uma lista 1D, nesse caso, você pode apenas levar n $n$$n^2$ como entrada adicional).

Casos de teste

Verdade:

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

Todas as versões retornam false para centrosymmetric ou true para não-centrosymmetric.

Matriz unidimensional + comprimento, tamanho 9 (89 bytes)

Recebe entrada na sintaxe de curry (length)(array), em que a matriz é unidimensional.

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

Experimente online!

Matriz + largura, tamanho 11 (131 bytes)

Recebe entrada na sintaxe 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/**/

Experimente online!

Carga útil

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

Recipiente

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

Apenas matriz, tamanho 12 (155 bytes)

Esta é a minha solução original, que calcula a largura da matriz sozinha.

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

Experimente online!

Quão?

Precisamos de alguns tokens críticos que não podem ser divididos:

• some
• length
• )=>

Os feeds de linha podem ser inseridos quase em qualquer outro lugar.

O código de carga útil desenrolado é lido como:

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

e está dentro da seguinte estrutura:

/**/CODE////*/

que, uma vez revertido, se torna um comentário de bloco válido:

/*////EDOC/**/

Geléia , pontuação 2

⁼Ṛ
Ṛ⁼

Experimente online!

Recebe entrada como uma matriz quadrada achatada (vetor de tamanho ).$n^2$

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

Experimente online!

Entrada: n seguida pelos elementos da matriz, todos separados por espaços. NOTA: pode ser necessário usar um intérprete diferente se você tiver uma entrada grande o suficiente.

Tenho certeza de que há uma maneira melhor de fazer isso, eu só queria tentar isso no Befunge. A parte do código real é a metade superior.

Quão?

O código é dividido em duas seções principais, a inicialização e a verificação .

Inicialização:

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

Esta seção do código grava a matriz de entrada logo abaixo do código como caracteres ASCII. Esta e a próxima seção usam as três células no canto superior esquerdo do código como dados. Eles são armazenados como n, i, j.

Verificação:

                     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$

As outras partes do código são lixo não lido para torná-lo centrossimétrico.

$n = 8$

Sem comentários!

Recebe entrada como uma lista 1-D

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

Experimente online!

$n= 10$

Recebe entrada como uma matriz 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

Experimente online!

Obrigado a potato44 por toda a ajuda no chat. E Lynn por jogar golfe fora de linha.

Explicação

A idéia geral aqui é simples, nós concatlistamos e comparamos com a inversa. No entanto, como queremos ser centrossimétricos, precisamos seguir com cuidado. Primeiro, escrevemos o código como normalmente:

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

Agora, para que nossas linhas reversas também sejam válidas Haskell, precisamos que o lado esquerdo de nossas equações pareça uma definição de função tacnoc.)esrever>*<)==(( .

O primeiro passo para corrigir isso é descartar parênteses.

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

No entanto, temos alguns novos problemas agora. Ambos .e ==quando revertidos são os mesmos, portanto, nossas linhas revertidas tentam redefinir os operadores ( <*>revertido é >*<assim, estamos bem nessa frente). .pode ser substituído por, <$>pois as funções são functors. E podemos substituir ==por /=, o que nega nossa produção, mas isso ainda está dentro das especificações. Agora temos

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

A fim de reduzir o comprimento da linha, alias concate reverse.

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

Agora apenas terminamos isso, tornando tudo centrossimétrico e quadrado.

A versão 1-D mais curta funciona da mesma maneira, exceto porque não há necessidade de concatsalvar duas linhas removendo-a.

Python 2 , tamanho 10 (109 bytes)

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

Experimente online!

Python 2 anterior , tamanho 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

Experimente online!

Pitão, tamanho 6 (41 bytes)

q_M_QQ
q.q   


   q.q
QQ_M_q

Experimente aqui

Explicação

A primeira linha inverte a entrada e cada linha e verifica se ficamos com uma cópia da entrada.
O .qna segunda linha sai do programa, então tudo depois disso, assim como o qanterior, é um no-op.

APL (Dyalog Unicode) , pontuação 7 6 5 4

Programa completo. Solicita a expressão da matriz de stdin. Imprime 1 ou 0 e, em seguida, gera um erro consistente. Sem comentários!

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

Experimente online!

⎕ pronto para a expressão e avaliá-la
, RAVeL (achatar) que
r← armazena o resultado em r(para r avelled)

⌽r espelho r
r≡ implicitamente imprimir se ré idêntico ao

≡ profundidade de r(dá 1)
r⌽ use rpara girar isso
^{(isso sempre causará RANK ERRORae sair porque uma matriz não é permitida como argumento à esquerda ⌽)}

Perl 6 , tamanho 9 8 7

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

Experimente online!

reverseé o gargalo aqui. Eu mudei para o tecnicamente mais longo, mas muito mais divisível [*-1 X-^*]. Ok, mudei para [R,]depois de ver a resposta de Brad Gilbert para outra pergunta.

O código achatado é {.flat eq [R,] .flat}.

Edit: Porra, eu percebi que nem preciso achatar a primeira lista, mas as tentativas de encurtá-la para um tamanho 6 falharam com apenas um byte a mais para caber ...

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

:(

Embora se a considerarmos como uma matriz unidimensional, é fácil ajustá-la no tamanho 6.

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

Experimente online!

Wolfram Language (Mathematica) (apenas REPL), tamanho 8 (71 bytes)

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

Retorna Truepara entrada centrosymmetric, e Falsecaso contrário.

No Mathematica REPL, as linhas com erros de sintaxe são ignoradas (com uma barra vermelha grossa aparecendo na lateral da tela). Aqui, apenas as três primeiras linhas,f=#[[c=-1;;1;;-1,c]]==#& , são executadas.

Este código captura a função no nome f.

Infelizmente, o built-in PalindromeQé muito longo.

Pyt , tamanho 1

₽

Experimente online!

Verifica se a entrada (na forma de linhas concatenadas) é um palíndromo.

Japt , tamanho 9 4 (11 bytes)

UªSê


êSªU

Experimente online!

Recebe entrada unidimensional, verifica se é um palíndromo. Se desejar, você pode preencher as duas linhas vazias para obter algumas artes ascii.
A versão bidimensional antiga, gira a entrada duas vezes e verifica se é igual ao original:

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

Experimente online!

Casca , tamanho 3

Ṡ=↔
=↔=
↔=Ṡ

Experimente online!Entrada como 1D-List. Cada linha define uma função, mas somente a da primeira linha é chamada.

Ṡ=↔é um palíndromo que verifica se a entrada é igual a ( =) sua reversa ( ↔).

Casca , tamanho 4

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

Experimente online! Para entrada como matriz 2D, concatenamos ( Σ) a lista de listas antes de verificar se é um palíndromo.

MATL , pontuação 4

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

A entrada possui o formato [1 2; 2 1], usando; como separador de linhas.

A saída é via STDERR ( permitido por padrão):

• Para entrada centrossimétrica, é produzido um erro de erro consistente. Com as versões atuais do Linux e Octave no TIO, é produzida a seguinte saída STDERR (desconsiderando as linhas finais que começam comReal 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...
  

  O erro pode ser diferente dependendo das versões Linux e Octave, mas será consistente nas entradas.

• Para entrada não centrossimétrica, nenhum erro é produzido e a saída STDERR no TIO é

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

Experimente online!Ou verifique todos os casos de teste:

• Centrosimétrico: 1 , 2 , 3 , 4 , 5 , 6 .
• Não centrossimétrico: 1 , 2 , 3 , 4 , 5 , 6 .

Verifica o programa é centrossimétrico.

Explicação

%é o símbolo de comentário, que faz com que o restante da linha seja ignorado. Novas linhas também são ignoradas. Então o código é apenas

t,!P]=?P!,t

que faz o seguinte:

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

Toma a entrada como uma lista 2D! (Crédito a Ørjan Johansen)

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

Python 2 , tamanho 8

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

Experimente online!

Recebe entrada como uma lista 1D de linhas concatenadas (de comprimento $n^2$) e saídas via código de saída (0 para entradas simétricas, 1 caso contrário).

A lista é simplesmente verificada para ser um palíndromo. Se for, a cadeia de comparação a[::-1]!=a<_falha na !=etapa e curto-circuito; caso contrário, a variável desconhecida _é avaliada, travando o programa.

R , tamanho 9

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

Experimente online!

As últimas três linhas são o programa atual que recebe uma matriz 1D como entrada e verifica se é igual ao seu reverso. Valor de verdade: FALSO, Valor de falsidade: VERDADEIRO.

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

R + pryr, tamanho 9

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



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

Experimente online!

C # (.NET Core) , pontuação 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

Experimente online!

Toma entrada como matriz 1D en ² como comprimento; retornos falsepara centrosymmetric e truepara não-centrosymmetric. Esta versão usa, System.Linqmas não sei como ajustá-la no envio de código devido aos requisitos específicos do desafio. Código desenrolado:

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

A seguir, meu envio anterior que não usa o LINQ:

C # (.NET Core) , pontuação 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

Experimente online!

Código desenrolado:

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

Ruby , pontuação 9 8

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

Experimente online!

Um lambda tomando uma matriz achatada como entrada. Retorna true para centrosymmetric; false, caso contrário.

-1 graças a Mr.XCoder,

Desembalado:

->z{
  z == z.reverse
}

Limpar \ limpo , tamanho 9

Obrigado a Ørjan Johansen !

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

Experimente online!

Limpo , tamanho 10

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

Experimente online!

05AB1E , tamanho 3 (11 bytes )

ÂQq

qQÂ

Entrada como uma única lista.
Experimente online.

Eu acho que esse não conta ..; p

ÂQ
qâ

Entrada como uma única lista.
Experimente online.

Explicação:

         # 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

Algumas alternativas de tamanho 3 (11 bytes ):

R€R
QqQ
R€R

Matriz como entrada.
Experimente online.

RQ 
 q  
 QR

Lista única como entrada.
Experimente 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

Experimente online!

> <>, Tamanho 6

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

Experimente online!

(Acontece que é uma dor passar valor múltiplo para -v in tio)

A entrada é tomada como uma matriz unidimensional como o estado inicial da pilha com -v. Sai sem saída se a matriz é centrossimétrica, sai com um erro (imprime "Algo cheira a peixe ...") se não.

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

Eu não estava totalmente feliz com esse formato de saída, então aqui está o tamanho 7, que gera 1 como verdadeiro e 0 como falso.

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

Experimente online!

Stax , n = 3

$cr
=q=
rc$

Execute e depure

Explicação:

$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 é o melhor possível, porque preciso de pelo menos três comandos: Copiar, reverter e comparar

Stax , n = 4

Mrxr
M=qX
Xq=M
rxrM

Execute e depure

Explicação:

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 , tamanho 2 (5 bytes)

ê"
"ê

Tente

Java 10, tamanho 13 (181 bytes)

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

Experimente online.

Inspirado por @Charlie resposta # 's C .

Explicação Golfed:

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) , pontuação 11

Leva uma lista de int e n como argumentos. Retorna n como valor de verdade, 0 como falso.

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

Experimente online!

Javascript ES6, tamanho 8:

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

Javascript ES6, tamanho 7 (é válido?):

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

Teste:

<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 com o lambda salvo na variável denominada 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, tamanho 9

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

Experimente online!