Sono un palindromo. Tu sei?


103

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

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


12
Qualcuno potrebbe spiegare perché () () non sarebbe un palindromo ??
Emilio M Bumachar,

58
@EmilioMBumachar Prova a sostituire (con ae )con b. È ababun palindromo? No, dovrebbe essere abba. Quindi ()()non è nemmeno un palindromo; dovrebbe essere ())(.
DLosc,

7
Quelle soluzioni che usano interamente i commenti per rendere palindromico il programma mi sembrano una scappatoia :(
kennytm,

15
@kennytm Disattivarli sarebbe peggio, perché non esiste un modo soddisfacente per farlo obiettivamente in modo indipendente dal linguaggio. (Che cos'è un commento? Che ne dici di mettere la metà inutilizzata in una stringa letterale che viene scartata? Che dire dei linguaggi 2D in cui puoi avere un codice perfettamente eseguibile che semplicemente non viene mai raggiunto?)
Martin Ender,

9
()() is not a palindrome, but ())( is. Congratulazioni, sei arrivato su reddit!
numbermaniac,

Risposte:


137

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.


49
E simmetria rotazionale a 180 gradi, è bellissima.
ATaco,

7
... e simmetria lungo gli assi verticale e orizzontale :-)
Luis Mendo,

13
@SteakOverflow Brachylog utilizza una tabella codici personalizzata , quindi quei caratteri non sono codificati in UTF-8
DJMcMayhem

4
Ho aderito a questa community solo per votare questo programma. Wow.
Bill Michell,

4
@ATaco La combinazione di simmetrie sinistra / destra e su / giù implica una simmetria rotazionale di 180 gradi. ;)
Eric Duminil,

55

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.

1
Perché hai bisogno del finale _?
busukxuan,

34
@busukxuan Dalla domanda "Inoltre, il programma o la funzione che scrivi deve essere un palindromo stesso"
isaacg,

1
Perché così tanti voti ... Questa risposta non sembra così difficile da trovare ...?
ghosts_in_the_code il

1
Credo di si. Sembra comunque ingiusto. Su alcune domande, è necessario impegnarsi molto per rispondere, mentre altre sono molto più semplici. Tuttavia il pagamento è lo stesso. Tra l'altro ho anche votato: P
ghosts_in_the_code il

4
@ghosts_in_the_code Solo una delle mie risposte con 100+ è stata in realtà impegnativa da scrivere, ma ci sono risposte su cui ho trascorso giorni che hanno ottenuto solo una manciata di voti. Alla fine, tutto pareggia ...
Dennis,




23

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


21

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.


1
Puoi spiegare il codice?
bli,

1
@bli tutto dopo che --è un commento.
theonlygusti,

3
@theonlygusti Haskell è sufficientemente alieno da aiutare solo la metà.
Yakk,

@Yakk E 'una sorta di combinazione dei (==), reversee idfunzioni ( idè la funzione identità).
martedì

Puoi salvare 10 byte usando <*>invece di <$>e rimuovendo<*>id
faubi il

20

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!


Perché non soloÂQ
Neil A.

1
@NeilA. Anche il codice stesso deve essere un palindromo.
Adnan,

17

PHP, 55 byte

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

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


Soluzione subdola.
Martijn,

16

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

15

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.



9

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 .


È possibile salvare alcuni buoni byte eseguendo la charToRawconversione prima dell'assegnazione se modificando il modo in cui si imposta l' separgomento su scan:all((s<-charToRaw(scan(,"",,,"\n")))==rev(s))#))s(ver==)))"n\",,,"",(nacs(waRoTrahc-<s((lla
rturnbull

(Inoltre, questo approccio non funziona, ad esempio, per input éécon una codifica UTF-8, ma non credo che infrange le regole della sfida.)
rturnbull,

@rturnbull: grazie per gli input! Ho davvero provato éécon una latin1codifica.
Frédéric,

Dal momento che il test deve essere fatto in termini di carattere, penso che l'attuale programma infrange le regole.
Frédéric,

Non sono così sicuro che la versione precedente non infranga le regole. OP afferma: "Tra le altre cose, ciò significa che se si considera l'input come una sequenza di byte anziché come 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). "
rturnbull,

8

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!


8

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.


8

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.

1
TIO ha il supporto per sed ora. -rnon funziona, ma puoi semplicemente avvolgere il tutto in BASH. Provalo online!
Riley,

@Riley Grazie per aver usato intestazione e piè di pagina su TIO, grazie. La soluzione precedente era spostare il codice nell'elenco degli argomenti con -e, ma la tua strada è molto più bella. Stavo aspettando che venisse risolto, ma in questo modo non ho bisogno di farlo.
seshoumara,

7

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.

6

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 .


5

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

2
Linguaggio pulito! :)
DLosc,

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

Il tuo codice sorgente non è un palindromo!
seshoumara,

@seshoumara Aggiornato il codice
Prasanth Bendra,

Adesso va bene Forse menzionare il valore restituito se la stringa non è un palindromo, solo per completezza.
seshoumara,

@apsillers grazie ho modificato la risposta.
Prasanth Bendra,

Non esiste alcuna funzione f, il tuo codice non assegna la tua funzione freccia a una variabile, quindi non può essere chiamata
spex,

5

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¥UwU==Uw. In Japt, la parentesi lasciata all'inizio e alla fine di una funzione viene inserita automaticamente.


Tutto ha senso, tranne se wè una funzione che non accetta argomenti, come si applica U? È qualcosa del genere U.reverse()?
DLosc,

@DLosc Correct. Si inverte Uallo stesso modo di U.reverse().
Oliver,

4

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!


[[ $1 = `rev<<<$1` ]]è più corto. ( [[Sintassi di Bash , nessuna citazione necessaria)
Arthur2e5,

2
@ Arthur2e5 Ho provato il tuo suggerimento, ma penso che le citazioni in giro rev<<<$1siano necessarie anche nella [[...]]soluzione. Provalo con una stringa di input '[$]]$['(che è un palindromo). Con quelle citazioni aggiunte per farlo funzionare, la tua soluzione ha la stessa lunghezza della mia soluzione.
Mitchell Spector,

Ottima cattura! Ho dimenticato che l'RHS di ==in [[sarebbe stato interpretato come un casemodello simile.
Arthur2e5,

@ Arthur2e5 Penso ancora che probabilmente ci sia un modo intelligente per accorciarlo.
Mitchell Spector,

Funzionerà ancora se ci sono nuove righe nell'input? Penso che tu abbia bisogno di rev | tac anziché solo di rev.
b_jonas,

4

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


Richiedere che l'input sia già nello stack rende questo un frammento. Questa sfida richiede programmi o funzioni, non frammenti.
pepery

4

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


Credo che puoi salvare alcuni byte restituendo ints invece di chars.
DLosc,

Non so come controllare il conteggio dei byte, ma hai 160 byte, non 161.
Olivier Grégoire

È possibile salvare 2 byte restituendo 80 per 'P'e 78 per 'N'o utilizzare caratteri diversi per salvare ancora più byte.
Selim,

1
Puoi salvare ancora più byte facendo new StringBuffer(s).reverse()+""invece dinew StringBuffer(s).reverse().toString()
Selim il

1
qualche motivo per cui stai restituendo un intinvece di bool?
CodesInChaos,

4

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

Questo codice non è un'espressione lambda.
Jakob,

@Jakob Ho pensato che lo fosse. Se dovessi usare la lambda, probabilmente vorresti una nuova riga iniziale e finale. (Ho aggiunto un link tio)
NonlinearFruit

Sì, la mia lamentela è stata che il commento alla riga rende la presentazione più di una semplice espressione lambda e quindi non valida come soluzione lambda. Non ti preoccupare per ora; Probabilmente alla fine farò un meta post per raccogliere consenso.
Jakob,

Le soluzioni @Jakob Lambda a volte possono avere un codice estraneo , motivo per cui penso che sia valido. Ma se non sei venduto, un meta post non farebbe male.
NonlinearFruit

1
So che è passato un po 'di tempo, ma puoi golf 2 byte cambiandolo in s->s.contains(new StringBuffer(s).reverse())//))(esrever.)s(reffuBgnirtS wen(sniatnoc.s>-s. Provalo online 90 byte .
Kevin Cruijssen,

3

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

Perché non basta fare questo ?
Leaky Nun,

1
@LeakyNun deve essere un palindromo
caird coinheringaahing

3

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


3

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.

2

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

Prova questo:l_W%#e#%W_l
aditsu,

2

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