La matrice est-elle centrosymétrique… et le code aussi?

37

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 ,UNEn×nA i ,je,j([1,n]Z)

UNEje,j=UNEn+1-je,n+1-j

Exemples de telles matrices

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

Centrosymmetric 5 by 5 matrix illustrée de façon vraiment sympa

Une matrice centrosymétrique de longueur égale ( ):4×4

(1234567887654321)

Et un côté impair ( 3×3 ) un:

(123565321)

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

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

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]]
M. Xcoder
la source
1
Hmm, cela semble encore assez difficile pour les langages non golfeurs, car il casse les parenthèses et les crochets sans commentaire. Une approche naïve consisterait à terminer chaque ligne par un caractère de commentaire (comme celui de Python #), de sorte que la moitié inférieure du code constitue un commentaire.
JungHwan Min
@JungHwanMin Dans ce cas particulier, Python #ne fonctionnera pas car les commentaires précédés de #sont en ligne uniquement: P
M. Xcoder
1
Double possible de Je suis un palindrome. Es-tu?
Pavel
6
Je suppose que je ne ferai que me démarquer, car les restrictions sur la source changent beaucoup les choses et le critère de gain est différent. A mon avis, ces différences suffisent. De plus, il existe d’autres techniques (dans de nombreuses langues plus courtes, comme Mathematica) qui peuvent être utilisées à la place de la vérification aplatie + palindrome.
M. Xcoder
1
@WW En bref, garder le défi simple et éviter tout type de cas indésirables. En outre, le garder carré est plus intuitif pour moi.
M. Xcoder le

Réponses:

20

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/**/
Arnauld
la source
18

Gelée , score 2

⁼Ṛ
Ṛ⁼

Essayez-le en ligne!

Prise en entrée sous forme de matrice carrée aplatie (vecteur de taille ).n2

Erik le golfeur
la source
15

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

je,jUNEje,j=UNEn+1-je,n+1-jj8

je=(n+1)-je

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.

Zacharý
la source
15

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

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.

Assistant de blé
la source
Que diriez-vous de cela pour n = 10?
Lynn
@ Lynn Merci! Dans ma tête, l'inverse <$>était aussi <$>.
Wheat Wizard
9

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!

Chas Brown
la source
1
Je ne sais pas si cela suffirait pour un réarrangement mais à titre d'information -i-1et -j-1pourrait tout simplement être ~iet~j
M. Xcoder
@M. Xcoder: J'ai un peu bricolé avec ça, mais ça ne change pas le résultat.
Chas Brown
Fonctionne également en python3.6, mais pourrait ne pas être optimal.
SIGSTACKFAULT
8

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.


la source
8

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 )

Adam
la source
7

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!

Jo King
la source
6

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.

JungHwan Min
la source
6

Pyt , taille 1

Essayez-le en ligne!

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

Lynn
la source
._. Eh bien, ce n'est pas centrosymétrique selon le défi:n> =2mais bon travail.
Zacharý
6
Par ma compréhension le n2est une contrainte sur l'entrée, pas sur la définition d'une matrice centrosymétrique.
Lynn
Oups, j'ai oublié ça.
Zacharý
5

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!

Lente
la source
1
Agréable! Je pense que j'ai un 6 et j'essaie de battre un 4 peu coopératif dans la soumission aussi, mais ils sont tous deux beaucoup plus triviaux que cela.
Shaggy
@Shaggy J'ai réussi à obtenir la même solution à six après avoir jeté un nouveau regard, quatre serait très impressionnant.
Nit
Étant donné que l'entrée peut (maintenant) être un tableau à 1 dimension, cela peut être fait avec un score de 2.
Shaggy
@Shaggy Je ne sais pas si je vois comment, la source doit être NxN.
Nit
comme si
Shaggy
4

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.

Laikoni
la source
3

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)
Luis Mendo
la source
3

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
Homme de programme
la source
Bugs: Deuxième <*>devrait être >*<. Dans la version 2D, il y a une partie manquante -et la partie inversée n'a pas les espaces aux bons endroits.
Ørjan Johansen
2

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

Lynn
la source
2

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!

JayCe
la source
2

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;
}
Charlie
la source
Si vous passez intà var(donc aussi tnià rav), la deuxième soumission fonctionne également en JavaScript.
Zacharý
2

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
}
benj2240
la source
2

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!

Οurous
la source
1
Ce n'est pas à cause de newline, cela fonctionne avec indent. 9 lignes
Ørjan Johansen
@ ØrjanJohansen Je ne peux pas croire que j'ai oublié que vous pouviez les indenter. Merci!
ousurous
Je vous en prie, et après la publication de mon commentaire, j'ai modifié la ligne médiane m.
Ørjan Johansen
@ ØrjanJohansen J'ai mis à jour la réponse pour refléter cela. C'est aussi très élégant.
ousurous
2

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.

Kevin Cruijssen
la source
1

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!

Jonathan Frech
la source
1

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

Sasha
la source
Bon travail! > <> peut être un langage amusant à utiliser, sauf s’il s’agit d’un programme complexe, c’est pénible.
mbomb007
1
si vous échangez les valeurs de vérité et de falsey, vous pouvez le réduire à 4 avec{-?;
Jo King
1

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
wastl
la source
1

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
Kevin Cruijssen
la source
1

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!

gastropner
la source
0

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

Qwertiy
la source
0

Clojure, Taille 9

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

Essayez-le en ligne!

Lispy Louie
la source