Ci sono stati un paio di precedenti tentativi di porre questa domanda, ma nessuno dei due è conforme agli standard moderni su questo sito. Per discussione su Meta , lo sto ripubblicando in modo da consentire una concorrenza leale nell'ambito dei nostri moderni set di regole.

sfondo

Un palindromo è una stringa che "legge la stessa avanti e indietro", cioè il contrario della stringa è uguale alla stringa stessa. Non stiamo parlando di "comodi palindromi" qui, ma di una rigida inversione carattere per carattere; per esempio, ()()non è un palindromo, ma lo ())(è.

L'obiettivo

Scrivi un programma o una funzione che accetta come input una stringa S (o l'equivalente appropriato nella tua lingua) e ha un output Q (di un tipo a tua scelta). È possibile utilizzare qualsiasi mezzo ragionevole per accettare l'input e fornire l'output.

• Quando l'ingresso S è un palindromo, l'uscita Q dovrebbe avere un valore A (che è lo stesso per qualsiasi S palindromica ).
• Quando l'ingresso S non è un palindromo, l'uscita Q dovrebbe avere un valore B (che è lo stesso per qualsiasi S non palindromica ).
• A e B devono essere distinti l'uno dall'altro.

O in altre parole: associa tutti i palindromi a un valore e tutti i non palindromi a un altro.

Inoltre, il programma o la funzione che scrivi deve essere un palindromo stesso (ovvero il suo codice sorgente deve essere palindromico), rendendolo una sfida a fonte limitata .

chiarimenti

• Sebbene truee falsesiano scelte ovvie per A e B , puoi usare due valori distinti per i tuoi output "è un palindromo" e "non è un palindromo", che non devono essere booleani.
• Qui stiamo definendo l'inversione di stringa a livello di carattere ; ééè palindromico indipendentemente dal fatto che il programma sia codificato in UTF-8 o Latin-1, anche se non è una sequenza palindromica di ottetti dopo la codifica UTF-8.
• Tuttavia, anche se il tuo programma contiene caratteri non ASCII, deve funzionare solo per l'input ASCII. In particolare, l'ingresso S conterrà solo caratteri ASCII stampabili (incluso lo spazio, ma non la nuova riga). Tra le altre cose, ciò significa che se si considera l'input come una sequenza di byte piuttosto che una sequenza di caratteri, è probabile che il programma sia ancora conforme alle specifiche (a meno che la codifica I / O della propria lingua non sia molto strana). In quanto tale, la definizione di palindromo nel proiettile precedente conta davvero solo quando si controlla che il programma abbia una forma corretta.
• Nascondere metà del programma in un commento o stringa letterale, pur non essendo creativo, è legale; vieni valutato sulla lunghezza, non sulla creatività, quindi sentiti libero di usare metodi "noiosi" per assicurarti che il tuo programma sia un palindromo. Ovviamente, poiché ti viene assegnato un punteggio in lunghezza, parti del tuo programma che non fanno nulla peggioreranno il tuo punteggio, quindi essere in grado di utilizzare entrambe le metà del programma sarà probabilmente utile se riesci a gestirlo .
• Poiché il criterio di vittoria è misurato in byte, dovrai specificare la codifica in cui è scritto il tuo programma per essere in grado di assegnarlo (anche se in molti casi sarà ovvio quale codifica stai utilizzando).

Criterio di vittoria

Anche se il programma deve essere un palindromo a livello di personaggio, stiamo usando i byte per vedere chi vince. In particolare, più breve è il tuo programma, misurato in byte, meglio è; questa è una sfida di code-golf . Per consentire il confronto degli invii (in particolare gli invii nella stessa lingua), inserire un conteggio di byte per il programma nell'intestazione dell'invio (più un conteggio di caratteri, se diverso dal numero di byte).

Brachylog (2), 3 byte nella tabella codici di Brachylog

I↔I

Provalo online!

Questo è un programma completo che accetta input tramite input standard (utilizzando la sintassi di Brachylog per le costanti, ovvero le stringhe sono racchiuse tra virgolette doppie) e output tramite output standard. Le uscite sono true.per un ingresso palindromico e false.per un ingresso non palindromico.

Questo programma non è solo palindromico, ma ha anche una simmetria speculare sinistra / destra (e probabilmente in alcuni caratteri su / giù).

Spiegazione

In Brachylog, le lettere maiuscole segnano punti nel programma che hanno valori identici; questo è usato quasi come un circuito elettrico per trasportare informazioni da una parte del programma a un'altra. Una conseguenza di ciò è che se racchiudi un comando tra una coppia identica di lettere maiuscole, stai effettivamente affermando che l'input e l'output del comando sono gli stessi. Brachylog prende implicitamente input, quindi in questo caso stiamo anche affermando che l'input per il comando è lo stesso dell'input per il programma. In questo programma, stiamo usando il comando ↔, che inverte le cose (in questo caso, le stringhe); quindi il programma afferma efficacemente che l'input è lo stesso avanti e indietro.

Un programma completo (al contrario di una funzione) in Brachylog restituisce un valore booleano, false.se non c'è modo di correggere tutte le asserzioni nel programma contemporaneamente o true.se le asserzioni nel programma sono tutte compatibili tra loro. Abbiamo solo un'asserzione qui - che l'inversione dell'input non lo cambia - quindi il programma funge da controllo del palindromo.

Pyth , 3 byte

_I_

Restituisce Vero o Falso .

Provalo online!

Come funziona

  _  Reverse the input.
_I   Invariant-reverse; test if the reversed input is equal to its reverse.

Python , 39 byte

lambda s:s[::-1]==s#s==]1-::[s:s adbmal

Provalo online!

Noioso, ma se c'è più breve in Python sarà impressionante.

Gelatina , 5 byte

ḂŒ
ŒḂ

Restituisce 1 o 0 . La prima riga è un collegamento helper non eseguito, la seconda riga chiama il test palindromo.

Provalo online!

Gelatina , 5 byte

⁼ṚaṚ⁼

Provalo online!

Equivale al contrario e al contrario è uguale

O il più efficiente ma meno esteticamente piacevole:

⁼Ṛ
Ṛ⁼

o

Ṛ⁼
⁼Ṛ

Mathematica, 23 byte

QemordnilaP;PalindromeQ

Non molto interessante, ma per completezza ...

Quanto sopra è un CompoundExpressionoggetto da valutare PalindromeQ, un built-in che risolve la sfida. QemordnilaPè semplicemente un identificatore indefinito, che viene ignorato a causa di ;.

Haskell, 87 85 44 34 byte

p=(==)<*>reverse--esrever>*<)==(=p

Spiegazione: ((->) a)è un'istanza di Applicativo (grazie a @faubiguy), con <*>definito come

(<*>) f g x = f x (g x)

Quindi sostituendo gli argomenti si può capire perché questo funziona.

05AB1E , 3 byte

Codice:

ÂQÂ

Spiegazione:

     # Bifurcate (duplicate and reverse the duplicate) implicit input
 Q    # Check if equal
  Â   # Bifurcate the result

Utilizza la codifica CP-1252 . Provalo online!

PHP, 55 byte

<?=strrev($s=$_GET[s])==$s;#;s$==)]s[TEG_$=s$(verrts=?<

Inoltre, il nome della lingua è un palindromo, quindi ... punti bonus!

MATL , 7 byte

tPX=XPt

Provalo online!

Restituisce [1; 1] per input palindromico e [0; 0] altrimenti.

t       % duplicate the input
P       % reverse the second string
X=      % check the two strings are exactly equal (returns 0 or 1)
XP      % flip array (does nothing)
t       % duplicate the answer, giving either [1;1] or [0;0]
        % (implicit) convert to string and display

Pip , 12 11 byte

Ora senza commenti!

x:RVaQaVR:x

Accetta input come argomento della riga di comando; uscite 1per palindromo, 0per non palindromo. Provalo online!

Il nucleo di quello che vogliamo fare è RVaQa: reverse(a) string-equals a. Il codice x:RVaQacalcola questo risultato e lo assegna a x. Quindi VR:xassegna il valore di xalla variabile VR. Poiché questa assegnazione è l'ultima istruzione del programma, anche il suo valore viene stampato automaticamente. Ecco!

Per una versione interessante precedente che utilizzava comportamenti non definiti, consultare la cronologia delle revisioni.

Perl 6 , 25 byte / caratteri utf8

{.flip eq$_}#}_$qe pilf.{

Provalo

R, 111 103 byte

all((s<-el(strsplit(scan(,"",,,"\n"),"")))==rev(s))#))s(ver==)))"",)"n\",,,"",(nacs(tilpsrts(le-<s((lla

Non è la risposta più originale. #è il carattere di commento in R

Ungolfed:

all((s<-el(strsplit(scan(,"",,,"\n"),"")))==rev(s))
#
))s(ver==)))"",)"n\",,,"",(nacs(tilpsrts(le-<s((lla

La stringa di caratteri da scanviene convertita in byte non elaborati grazie alla charToRawfunzione. Questi byte grezzi vengono confrontati uno a uno con le loro controparti dalla rev()funzione, che inverte l'ordine del suo argomento. L'output di questa parte è un vettore di TRUEe / o FALSE.
La allfunzione quindi emette TRUEse tutti questi elementi lo sonoTRUE

Qui, "\n"nella scanfunzione è necessario per input con più di una parola.

Risposta precedente (byte-saggio), 81 byte

function(s)all((s=charToRaw(s))==rev(s))#))s(ver==))s(waRoTr‌​ahc=s((lla)s(noitcnu‌​f

con - 24 byte grazie a @rturnbull .

RProgN , 11 byte

~]S.E E.S]~

La prima metà di questo fa tutto il sollevamento pesante, e per comodità di RProgN, la seconda metà è una No-op.

~]S.E E.S]~
~           # Treat the word as a Zero Space Segment
 ]          # Duplicate the top of the stack
  S.        # Reverse the top of the stack
    E       # Compare if these values are equal
      E.S]~ # A no-op, because the ~ is at the end of the word, not the start.

Provalo online!

Retina , 53 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

$
¶$`
O$^`\G.
»
D`
M$`^.+$
$+.^`$M
`D
»
.G\`^$O
`$¶
$

Provalo online!

Sono abbastanza sicuro che non sia ancora ottimale (la »linea sembra particolarmente dispendiosa e ho una soluzione a 45 byte che è palindromica tranne un carattere), ma immagino sia un inizio.

GNU sed , 64 59 + 1 (flag r) = 60 byte UTF-8

Mi ci è voluto un po 'per trovare una risposta sed che non utilizza una sezione di commento per rendere il codice un palindromo. Al contrario, utilizzo il ccomando che stampa la prima metà del codice in ordine inverso, solo per essere sicuro che questa istruzione non venga raggiunta.

:;s:^(.)(.*)\1$:\2:;t;/../c1
d
1c/../;t;:2\:$1\)*.().(^:s;:

Lo script viene stampato 1se la stringa di input non è un palindromo (pensate che dia un errore). Se la stringa è un palindromo, allora non viene fornito alcun output (pensalo come uscire con successo).

Esegui esempi: o provalo online!

me@LCARS:/PPCG$ sed -rf palindrome_source.sed <<< "level"
me@LCARS:/PPCG$ sed -rf palindrome_source.sed <<< "game"
1

Spiegazione:

:                              # start loop
s:^(.)(.*)\1$:\2:              # delete first and last char, if they are the same
t                              # repeat if 's' was successful
/../c1                         # if at least 2 chars are left, print 1. 'c' reads
                               #till EOL, so next command must be on a new line.
d                              # delete pattern space. This line must be a
                               #palindrome itself, and must end the script.
1c/../;t;:2\:$1\)*.().(^:s;:   # (skipped) print first half of code in reverse
                               #order. Everything after 'c' is treated as string.

Alice , 19 byte

/@.nzRoi\
\ioRzn.@/

Provalo online!

Stampe Jabberwockyper palindromi e niente per i non palindromi. Funziona con input UTF-8 arbitrario.

Spiegazione

Poiché si tratta di un'attività di elaborazione delle stringhe, Alice dovrà operare in modalità Ordinale per risolverlo. Ciò a sua volta significa che il puntatore dell'istruzione deve spostarsi in diagonale, e quindi abbiamo bisogno di almeno due linee in modo che l'IP possa rimbalzare su e giù. L'alimentazione di linea in un programma del genere costituisce una buona posizione per posizionare il personaggio centrale del palindromo. Ciò significa che la seconda riga deve essere il contrario della prima. Ma poiché stiamo eseguendo solo tutti gli altri caratteri su ogni riga, se ci assicuriamo che la lunghezza della riga sia dispari, il contrario del codice si adatterà perfettamente ai propri spazi. L'unico personaggio che non viene affatto utilizzato è la barra rovesciata, ma poiché era arbitrario l'ho scelto per rendere il programma bello e simmetrico.

Quindi, il vero codice rilevante è questo:

/ . z o
 i R n @

Che viene eseguito a zigzag da sinistra a destra.

/   Reflect the IP southeast, enter Ordinal mode.
i   Read all input as a single string.
.   Duplicate the input.
R   Reverse the copy.
z   Pop the reverse Y and the original X. If X contains Y, drop everything
    up to its first occurrence. Since we know that X and Y are the same length,
    Y can only be contained in X if X=Y, which means that X is a palindrome.
    So this will result in an empty string for palindromes and in the non-empty
    input for non-palindromes.
n   Logical NOT. Replaces non-empty strings with "", and empty strings with
    "Jabberwocky", the "default" truthy string.
o   Output the result.
@   Terminate the program.

Haskell , 34 byte

f=(==)=<<reverse--esrever<<=)==(=f

Provalo online! Chiama con f "some string", ritorna Trueo False.

L' =<<operatore su funzioni funziona in modo simile f=<<g = \s -> f (g s) s, quindi il codice è equivalente a f s=s==reverse s, che, come ho appena notato, si tradurrebbe nello stesso conteggio dei byte.

Versione senza commento: (49 byte)

e x y=x/=y
p=e=<<reverse
esrever<<=e=p
y=/x=y x e

Provalo online!

Chiama con p "some string". Questo produce Falsese la stringa data è un palindromo e Truese non è un palindromo.

Spiegazione:

Ho trovato questo commento gratuito palindrome iniziando con la versione del commento e sostituendo il commento con una nuova riga:

p=(==)=<<reverse
esrever<<=)==(=p

La seconda riga non riesce perché la parentesi non corrisponde, quindi è necessario eliminarla. Se avessimo una funzione eche controlla l'uguaglianza, allora

p=e=<<reverse
esrever<<=e=p

saranno entrambi compilare con la seconda linea che definisce un infisso-operatore <<=che prende due argomenti esrevere ee restituisce la funzione p.

Per definire ecome la funzione di uguaglianza si dovrebbe normalmente scrivere e=(==), ma di )==(=enuovo non compilare. Invece potremmo prendere esplicitamente due argomenti e passarli a ==: e x y=x==y. Ora il codice invertito viene y==x=y x ecompilato ma ridefinisce l' ==operatore, causando errori nella definizione e x y=x==y. Tuttavia, se passiamo all'operatore di disuguaglianza /=, la definizione inversa diventa y=/x=y x ee definisce un =/operatore che non interferisce con l' /=operatore originale .

OLIO , 178 byte

Legge un input, lo esplode, aggiunge lentamente la sua lunghezza (attraverso l'incremento e il decremento) all'indirizzo per conoscere l'indirizzo dopo la stringa, passa a una parte diversa del codice (al centro), inverte la direzione della banda, implode la stringa di nuovo e verifica se è uguale alla stringa originale. TL; DR: È un dolore, come al solito.

Emette 40se la stringa non è un palindromo, 0se lo è.

5
0
12
0
40
1
40
2
1
40
34
10
2
3
22
16
9
2
8
35
6
11
6
37

3
4
4
27
26
0
1
10
1

40
13
2
31
04

1
01
1
0
62
72
4
4
3

73
6
11
6
53
8
2
9
61
22
3
2
01
43
04
1
2
04
1
04
0
21
0
5

Javascript, 64 byte

f=s=>s==[...s].reverse().join``//``nioj.)(esrever.]s...[==s>=s=f

Funzione di chiamata fcon stringa

f("abba") // returns true
f("abab") // returns false

Japt , 7 2 byte

êê

Eseguirlo

Vecchia soluzione:

U¥UwU¥U

Provalo online!

Spiegazione

U¥UwU¥U
U¥        U is the input, ¥ is a shortcut for == 
  Uw      w is a reverse function.
    U¥U   This calculates U == U (always true), but the result is ignored
          because w does not look at its arguments.

Japt non sfugge alle funzioni a meno che non venga raggiunta una parentesi (o spazio) di chiusura.

Questo può essere riscritto: U¥Uw(U¥U)→ U¥Uw→ U==Uw. In Japt, la parentesi lasciata all'inizio e alla fine di una funzione viene inserita automaticamente.

Utilità Bash + Unix, 49 byte

[ "$1" = "`rev<<<$1`" ] # ] "`1$<<<ver`" = "1$" [

L'input viene passato come argomento.

L'output viene restituito nel codice risultato - 0 per un palindromo, 1 per un non-palindromo.

Forse qualcuno può fare di meglio e non fare semplicemente affidamento su un commento per rendere il codice stesso palindromico.

Provalo online!

> <>, 11 byte

{=?!;
;!?={

Provalo qui!

Restituisce "\ nqualcosa puzza di pesce ..." su un palindromo valido, nessuna uscita su un palindromo non valido. Posiziona il palindromo in pila.

Java - 171 169 160 byte

int q(String s){return s.equals(new StringBuffer(s).reverse().toString())?1:2;}//};2:1?))(gnirtSot.)(esrever.)s(reffuBgnirtS wen(slauqe.s nruter{)s gnirtS(q tni

Il commento alla fine è quello di renderlo un palindromo. Restituisce P(alindrome)quando l'ingresso è palindromo e N(ot)quando no.

Versione non golfata:

int q(String s) {
    return s.equals(new StringBuffer(s).reverse().toString()) ? 'P' : 'N';
}//};'N':'P'?))(gnirtSot.)(esrever.)s(reffuBgnirtS wen(slauqe.s nruter{)s gnirtS(q tni

2 byte salvati grazie a @DLosc

Grazie a @Olivier Grégoire per aver segnalato la quantità errata di byte! Riparato ora

Java 8, 92 90 byte

Questa è una versione di commento. Se una stringa contiene il suo rovescio, allora è un palindromo ( true) altrimenti non lo è ( false).

s->s.contains(new StringBuffer(s).reverse())//))(esrever.)s(reffuBgnirtS wen(sniatnoc.s>-s

Provalo online!

Aggiornare

• -2 [18-04-05] Passato a contiene. Grazie a @Kevin Cruijssen !
• -2 [17-02-20] rimossi ;'s
• -16 [17-02-22] Conversione automatica

In realtà , 5 byte

;R=R;

Provalo online!

L'output vero è [1]\n[1]e l'output falso è []\n[](in entrambi gli output, \nrappresenta una nuova riga letterale).

Spiegazione:

;R=R;
;R=    duplicate input, reverse one copy, test equality (the main palindrome-testing part)
   R   range(1, x+1) - if palindrome, this pushes [1], else it pushes []
    ;  duplicate

C ++, 154 byte

int m(){std::string g,p="";g=p;std::reverse(p.begin(),p.end());return g==p;}//};p==g nruter;))(dne.p,)(nigeb.p(esrever::dts;p=g;""=p,g gnirts::dts{)(m tni

Devo dire che la dichiarazione inversa è stata costosa, ma non riesco a immaginare molto che posso fare per cambiarlo. Essere in grado di ritagliare lo std :: simboli mi farebbe risparmiare circa 10 caratteri, ma "usando lo spazio dei nomi std;" è un bel po 'di più.

Suppongo che il C ++ non fosse realmente pensato per brevità.

Prolog, 44 byte

p-->[]|[_]|[E],p,[E].%.]E[,p,]E[|]_[|][>--p

Questo utilizza grammatiche di clausole definite. In realtà è una grammatica libera dal contesto completo:

p -->
      []            % the empty string
   |                % or
      [_]           % a one character string
   |                % or
      [E],          % one character, followed by
      p,            % a palindrome, followed by
      [E].          % that same character

Uso:

?- phrase(p,"reliefpfeiler").
true 

?- phrase(p,"re").
false.

CJam, 13 byte

l_W%=e#e=%W_l

Spiegazione:

l_W%=e#e=%W_l
l_            e#Read input twice
  W%          e#Reverse one input
    =         e#Test for equality
     e#e=%W_l e#Comment to be a palindrome

Esempio:

> l_W%=e#e=%W_l
l_W%=e#e=%W_l
1

> l_W%=e#e=%W_l
Hi
0

> l_W%=e#e=%W_l
hh
1

J, 15 byte, 15 caratteri

-:|.NB. .BN.|:-

Restituisce 1 se palindromo, 0 in caso contrario.

Produzione:

   f '())('
1
   f 'nope'
0

Spiegazione:

-:    NB. "Match" verb, checks for equality
|.    NB. Reverses the string