La matrice è centrosimmetrica ... e lo è anche il codice?


37

defintion

Una matrice centrosimmetrica è una matrice quadrata simmetrica rispetto al suo centro. Più rigorosamente, una matrice di dimensioni n × n è centrosimmetrica se, per qualsiasi iAn×n è soddisfatta la seguente relazione: A ii,j([1,n]Z)

Ai,j=An+1i,n+1j

Esempi di tali matrici

Ecco un'illustrazione della simmetria di matrici come queste (prese in prestito dal suddetto articolo di Wikipedia):

Matrice centrosimmetrica 5 per 5 illustrata in modo davvero piacevole

Una lunghezza pari ( matrice centrosimmetrica di 4 ):4×4

(1234567887654321)

E uno di lunghezza dispari ( ):3×3

(123565321)

Compito e specifiche

Data una matrice quadrata di dimensione almeno , genera uno di due valori distinti e coerenti, decidendo se la matrice è centrosimmetrica o meno. Puoi presumere che la matrice sarà composta interamente da numeri interi positivi.2

Tuttavia, anche il codice deve essere centrosimmetrico. Cioè, deve essere un programma / funzione (o equivalenti) costituito da righe, ognuna delle quali contenente n byte nella codifica della tua lingua, e deve soddisfare la definizione sopra indicata, ma con byte anziché numeri interi positivi. Il punteggio del tuo invio sarà il valore di n , con un n inferiore migliore.nn nn

Puoi prendere input e fornire output attraverso qualsiasi metodo standard e in qualsiasi formato ragionevole, tenendo presente che queste scappatoie sono vietate per impostazione predefinita. Puoi (facoltativamente) scegliere di prendere anche la dimensione, , come input (a meno che tu non prenda input come un elenco 1D, nel qual caso puoi prendere solo n 2nn2 come input aggiuntivo).

Casi test

Truthy:

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

1
Hmm, questo sembra ancora piuttosto difficile per le lingue non golf perché rompe parentesi e parentesi senza commenti. Un approccio ingenuo sarebbe quello di terminare ogni riga con un carattere di commento (come quello di Python #), in modo che la metà inferiore del codice sia un commento.
JungHwan Min,

@JungHwanMin In questo caso particolare, Python #non funzionerà perché i commenti preceduti da #sono solo in linea: P
Mr. Xcoder

1
Possibile duplicato di I'm a palindrome. Tu sei?
Pavel,

6
Immagino che mi limiterò a dissentire, poiché le restrizioni sulla fonte cambiano molto e il criterio vincente è diverso. Secondo me, queste differenze sono sufficienti. Inoltre, ci sono altre tecniche (in molte lingue più brevi - ad es. Mathematica) che possono essere utilizzate al posto di spianare + controllo palindromo.
Mr. Xcoder,

1
@WW In breve, per semplificare la sfida ed evitare qualsiasi tipo di caso limite indesiderato. Inoltre, tenerlo quadrato è più intuitivo per me.
Mr. Xcoder,

Risposte:


20

JavaScript (ES6), dimensione 12 11 9

Tutte le versioni restituiscono false per centrosimmetrica o true per non centrosimmetriche.


Matrice monodimensionale + lunghezza, dimensione 9 (89 byte)

Accetta input nella sintassi del curry (length)(array), in cui l' array è monodimensionale.

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

Provalo online!


Matrice + larghezza, dimensione 11 (131 byte)

Accetta input nella sintassi del curry (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/**/

Provalo online!

Carico utile

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

Contenitore

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

Solo matrice, dimensione 12 (155 byte)

Questa è la mia soluzione originale, che calcola la larghezza della matrice da sola.

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

Provalo online!

Come?

Abbiamo bisogno di alcuni token critici che non possono essere divisi:

  • some
  • length
  • )=>

I feed di riga possono essere inseriti quasi ovunque.

Il codice payload non sritto recita come:

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

ed è racchiuso nella seguente struttura:

/**/CODE////*/

che, una volta invertito, diventa un commento di blocco valido:

/*////EDOC/**/


15

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

Provalo online!

Ingresso: n seguito dagli elementi dell'array, tutti separati da spazi. NOTA: potrebbe essere necessario utilizzare un interprete diverso se si dispone di un input abbastanza grande.

Sono sicuro che c'è un modo migliore per farlo, volevo solo provare questo in Befunge. La parte di codice effettiva è la metà superiore.

Come?

Il codice è diviso in due sezioni principali, l' inizializzazione e la verifica .

Inizializzazione:

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

Questa sezione del codice scrive la matrice di input proprio sotto il codice come caratteri ASCII. Sia questa che la sezione successiva utilizzano le tre celle in alto a sinistra del codice come dati. Sono memorizzati come n, i, j.

Verifica:

                     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,jAi,j=An+1i,n+1jj8

i=(n+1)i

j=n+1(j8)+8=(n+1)+(8+8)j

Le altre parti di codice sono immondizia non letta per renderla centrosimmetrica.


15

n=8

Non ci sono commenti!

Accetta input come un elenco 1-D

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

Provalo online!

n=10

Accetta input come matrice 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

Provalo online!

Grazie a potato44 per tutto il loro aiuto in chat. E Lynn per il golf di fila.

Spiegazione

L'idea generale qui è semplice, noi concatla lista e la confrontiamo con il suo contrario. Tuttavia, poiché vogliamo essere centrosimmetrici, dobbiamo procedere con cautela. Per prima cosa scriviamo il codice come normalmente:

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

Ora, affinché anche le nostre linee inverse siano valide Haskell, abbiamo bisogno che il lato sinistro delle nostre equazioni assomigli ad una definizione di funzione tacnoc.)esrever>*<)==(( .

Il primo passo per risolvere questo problema è l'eliminazione delle parentesi.

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

Tuttavia ora abbiamo alcuni nuovi problemi. Entrambi .e ==quando invertiti sono gli stessi, quindi le nostre linee invertite tentano di ridefinire gli operatori ( <*>invertito è >*<quindi stiamo bene su quel fronte). .può essere sostituito <$>dal momento che le funzioni sono funzioni. E possiamo sostituirlo ==con /=, il che annulla il nostro output, ma è ancora all'interno delle specifiche. Ora abbiamo

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

Al fine di ridurre la lunghezza della nostra linea abbiamo alias concate reverse.

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

Ora finiamo semplicemente rendendo tutto centrosimmetrico e quadrato.

La versione 1-D più corta funziona più o meno allo stesso modo tranne per il fatto che non è necessario concatsalvare due righe rimuovendola.


Che ne dici di questo per n = 10?
Lynn,

@Lynn Grazie! Nella mia testa <$>era anche il contrario di <$>.
Wheat Wizard

9

Python 2 , dimensione 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

Provalo online!

Precedente Python 2 , dimensione 14 (209 byte)

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

Provalo online!


1
Non sono sicuro che sarebbe abbastanza per un riarrangiamento, ma FYI -i-1e -j-1potrebbe semplicemente essere ~ie~j
Mr. Xcoder

@Sig. Xcoder: ho armeggiato un po 'con quello, ma non cambia il risultato.
Chas Brown,

Funziona anche in python3.6, ma potrebbe non essere ottimale.
SIGSTACKFAULT,

8

Pyth, dimensione 6 (41 byte)

q_M_QQ
q.q   


   q.q
QQ_M_q

Provalo qui

Spiegazione

La prima riga inverte l'input e ogni riga e controlla se ci rimane una copia dell'input.
Il .qsecondo nella riga esce dal programma, quindi tutto ciò che segue, così come il qprecedente, è una no-op.


8

APL (Dyalog Unicode) , punteggio 7 6 5 4

Programma completo. Richiede l'espressione della matrice dallo stdin. Stampa 1 o 0 e quindi genera un errore coerente. Non ci sono commenti!

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

Provalo online!

 richiesta di espressione e valutazione
, ravel (appiattire)
r← memorizza il risultato in r(per r avelled)

⌽r specchio r
r≡ stampa implicitamente ser è identico a quello

 depth of r(dà 1)
r⌽ usare rper ruotare quello
 (questo causerà sempre a RANK ERRORed esce perché una matrice non è consentita come argomento sinistro )


7

Perl 6 , taglia 9 8 7

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

Provalo online!

reverseè il collo di bottiglia qui. L'ho cambiato in tecnicamente più lungo, ma molto più divisibile [*-1 X-^*]. Ok, l'ho cambiato [R,]dopo aver visto la risposta di Brad Gilbert di a un'altra domanda.

Il codice appiattito è {.flat eq [R,] .flat} .

Modifica: Accidenti, ho capito che non ho nemmeno bisogno di appiattire il primo elenco, ma i tentativi di accorciarlo a una dimensione 6 non sono riusciti con solo un byte di troppo per adattarsi ...

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

:(

Tuttavia, se lo prendiamo come un array monodimensionale, è facile adattarlo a una dimensione 6.

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

Provalo online!


6

Wolfram Language (Mathematica) (solo REPL), dimensione 8 (71 byte)

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

Restituisce Trueper input centrosimmetrico eFalse altrimenti.

Su Mathematica REPL, le linee con errori di sintassi vengono ignorate (con una spessa barra rossa che appare sul lato dello schermo). Qui, solo le prime tre righe,f=#[[c=-1;;1;;-1,c]]==#& vengono eseguite .

Questo codice acquisisce la funzione nel nome f .

Purtroppo, il built-in PalindromeQè troppo lungo.


6

Pyt , taglia 1

Provalo online!

Verifica se l'input (sotto forma di righe concatenate) è un palindromo.


._. bene, questo non è centrosimmetrico secondo la sfida:n> =2, ma bel lavoro.
Zacharý,

6
Dalla mia comprensione il n2è un vincolo sull'input, non sulla definizione di una matrice centrosimmetrica.
Lynn,

Spiacenti, l'ho dimenticato.
Zacharý,

5

Japt , dimensione 9 4 (11 byte)

UªSê


êSªU

Provalo online!

Accetta input monodimensionali, verifica se si tratta di un palindromo. Se lo desideri, puoi riempire le due righe vuote per alcuni disegni ASCII.
La vecchia versione bidimensionale, ruota due volte l'input e controlla se è uguale all'originale:

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

Provalo online!


1
Bello! Io penso ho un 6 e sto cercando di battere un poco collaborativo 4 alla sottomissione troppo, ma sono entrambi molto più banale di questo.
Shaggy,

@Shaggy Sono riuscito a ottenere la stessa soluzione fino a sei, dopo averla rinnovata, quattro sarebbero stati davvero impressionanti.
Nit

Dato che l'input può (ora) essere un array monodimensionale, questo può essere fatto con un punteggio di 2.
Shaggy

@Shaggy Non sono sicuro di vedere come, la fonte deve essere NxN.
Nit


4

Buccia , taglia 3

Ṡ=↔
=↔=
↔=Ṡ

Provalo online! Inserire come 1D-List. Ogni riga definisce una funzione, ma viene chiamata solo quella sulla prima riga.

Ṡ=↔è un test palindromo che verifica se l'input è uguale a ( =) e il suo reverse ( ).


Buccia , taglia 4

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

Provalo online! Per l'input come matrice 2D, concateniamo ( Σ) l'elenco degli elenchi prima di verificare che sia un palindromo.


3

MATL , punteggio 4

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

L'input ha il formato [1 2; 2 1], usando ;come separatore di riga.

L'output è tramite STDERR ( consentito per impostazione predefinita):

  • Per l'input centrosimmetrico viene prodotto un errore di errore coerente. Con le attuali versioni di Linux e Octave in TIO viene prodotto il seguente output STDERR (ignorando le righe finali che iniziano con 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'errore può essere diverso a seconda delle versioni Linux e Octave, ma sarà coerente tra gli input.

  • Per input non centrosimmetrici non viene prodotto alcun errore e l'uscita STDERR su TIO lo è

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

Provalo online!Oppure verifica tutti i casi di test:

  • Centrosimmetrico: 1 , 2 , 3 , 4 , 5 , 6 .
  • Non centrosimmetrico: 1 , 2 , 3 , 4 , 5 , 6 .

Dai un'occhiata che il programma sia centrosimmetrico.

Spiegazione

%è il simbolo del commento, che fa ignorare il resto della riga. Anche le newline vengono ignorate. Quindi il codice è giusto

t,!P]=?P!,t

che fa quanto segue:

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)


2

Python 2 , taglia 8

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

Provalo online!

Accetta input come un elenco 1D di righe concatenate (di lunghezza n2) e uscite tramite il codice di uscita (0 per ingressi simmetrici, 1 altrimenti).

L'elenco è semplicemente controllato per essere un palindromo. In tal caso, la catena di comparazione a[::-1]!=a<_non funziona in !=fase e cortocircuiti; in caso contrario _viene valutata la variabile sconosciuta , causando l'arresto anomalo del programma.


2

R , taglia 9

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

Provalo online!

Le ultime tre righe sono il vero programma che accetta un array 1D come input e controlla se è uguale al suo contrario. Valore vero: FALSO, Valore falso: VERO.

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

R + pryr, taglia 9

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



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

Provalo online!


2

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

Provalo online!

Accetta input come array 1D e n 2 come lunghezza; ritorni falseper centrosimmetrico e trueper non centrosimmetrico. Questa versione utilizzaSystem.Linq ma non so come inserirla nell'invio del codice a causa dei requisiti particolari della sfida. Codice srotolato:

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

Di seguito è riportato il mio precedente invio che non utilizza LINQ:

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

Provalo online!

Codice srotolato:

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

Se si intpassa a var(quindi anche tnia rav), anche il secondo invio funziona in JavaScript.
Zacharý,

2

Ruby , punteggio 9 8

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

Provalo online!

Un lambda che prende una matrice appiattita come input. Restituisce vero per centrosimmetrico, falso altrimenti.

-1 grazie a Mr.XCoder,

Unpacked:

->z{
  z == z.reverse
}

2

Pulito , taglia 9

Grazie a Ørjan Johansen !

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

Provalo online!

Pulito , taglia 10

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

Provalo online!


1
Non è a causa di Newline, funziona con rientro. 9 linee
Ørjan Johansen,

@ ØrjanJohansen Non riesco a credere di aver dimenticato di poterli rientrare. Grazie!
Οuroso

Prego, e ho modificato la linea di mezzo dopo aver pubblicato, deve solo essere m.
Ørjan Johansen,

@ ØrjanJohansen Ho aggiornato la risposta per riflettere ciò. Sembra davvero elegante anche in questo modo.
Οuroso

2

05AB1E , dimensione 3 (11 byte )

ÂQq

qQÂ

Inserisci come un unico elenco.
Provalo online.

Immagino che questo non conti ...; p

ÂQ
qâ

Inserisci come un unico elenco.
Provalo online.

Spiegazione:

         # 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

Alcune alternative di dimensione 3 (11 byte ):

R€R
QqQ
R€R

Matrice come input.
Provalo online.

RQ 
 q  
 QR

Elenco unico come input.
Provalo online.


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

Provalo online!


1

> <>, Dimensione 6

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

Provalo online!

(Si scopre che è un dolore passare più valori a -v in tio)

L'input viene considerato come un array monodimensionale come stato iniziale dello stack con -v. Esce senza output se la matrice è centrosimmetrica, esce con un errore (stampa "Qualcosa puzza di pesce ...") in caso contrario.

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

Non ero del tutto soddisfatto di questo formato di output, quindi ecco uno di dimensioni 7 che produce 1 per true e 0 per false.

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

Provalo online!


Bel lavoro! > <> può essere una lingua divertente con cui lavorare, a meno che non sia un programma complesso, quindi è una seccatura.
mbomb007,

1
se si scambiano i valori di verità e falsità, si può arrivare a 4 con{-?;
Jo King

1

Stax , n = 3

$cr
=q=
rc$

Esegui ed esegui il debug

Spiegazione:

$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 è il migliore possibile perché ho bisogno di almeno tre comandi: Copia, inverti e confronta

Stax , n = 4

Mrxr
M=qX
Xq=M
rxrM

Esegui ed esegui il debug

Spiegazione:

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


1

Java 10, dimensione 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

Provalo online.

Ispirato dalla risposta C # di @Charlie .

Spiegazione del golf:

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

1

C (gcc) , punteggio 11

Prende un elenco di int e n come argomenti. Restituisce n come valore di verità, 0 come 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;}//*/

Provalo online!


0

Javascript ES6, dimensione 8:

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

Javascript ES6, dimensione 7 (è valido?):

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

Test:

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

o con lambda salvato nella variabile denominata 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)))


Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.