Scrivi un programma per verificare se una stringa è palindromica, con l'aggiunta della condizione che il programma sia palindromico stesso.

Rubino

z=gets;puts *z.reverse==z&&1||0||1&&z==esrever.z* stup;steg=z

Stampa 1 se l'input è un palindromo, 0 se non lo è. Input senza interruzione di riga.

Non utilizza alcun commento, invece utilizza 2 trucchi:

• Cortocircuito: 0è vero in Ruby (solo nile falsevaluta falso), quindi 1&&z==esrever.z* stupnon viene valutato e quindi non può sollevare un'eccezione di runtime
• L'operatore splat / moltiplicazione ( *): per evitare un errore di sintassi in z=esrever.z stup, forziamo il parser a analizzarlo come z=esrever.z()*stupaggiungendo a *. Dall'altro lato, *viene analizzato come operatore splat, che in una chiamata di funzione divide un array in una serie di parametri. Se c'è solo un elemento invece di un array, sostanzialmente non fa nulla, quindi puts *fooequivale a puts foo.

Soluzione ovvia usando i commenti (stampa vero / falso):

puts gets.reverse==$_#_$==esrever.steg stup

Python senza commento

"a\";w=]1-::[w trinp;)(tupni_war=w;";w=raw_input();print w[::-1]==w;"\a"

Sono sorpreso che nessuno abbia ancora trovato quel trucco, dovrebbe funzionare nella maggior parte delle lingue!

Perl

perl -nle "$s=$_ eq+reverse;print$s;s$tnirp;esrever+qe _$=s$"

nessun trucco, abusando abilmente dell'operatore di sostituzione (ehi, anche le variabili perl iniziano con un $, e allora?)

Python 2.7

s=raw_input();print'YNEOS'[s!=s[::-1]::2]#]2::]1-::[s=!s['SOENY'tnirp;)(tupni_war=s

C

#include <stdio.h>                   //
#include <string.h>                  //
int main() {                         //
  char str[1024];                    //
  fgets(str, sizeof(str), stdin);    //
  int i = 0, j = strlen(str) - 2;    //
  for (; i < j; i++, j--)            //
    if (str[i] != str[j]) {          //
      printf("no\n");                //
      return 0;                      //
    }                                //
  printf("yes\n");                   //
}                                    //
//                                    }
//                   ;)"n\sey"(ftnirp  
//                                }    
//                      ;0 nruter      
//                ;)"n\on"(ftnirp      
//          { )]j[rts =! ]i[rts( fi    
//            )--j ,++i ;j < i ;( rof  
//    ;2 - )rts(nelrts = j ,0 = i tni  
//    ;)nidts ,)rts(foezis ,rts(stegf  
//                    ;]4201[rts rahc  
//                         { )(niam tni
//                  >h.gnirts< edulcni#
//                   >h.oidts< edulcni#

Esempio corrente:

$ gcc -std=c99 c.c && ./a.out 
blahalb
yes

Golfscript

.-1%=#=%1-.

• solo con il trucco dei commenti
• input senza \ n alla fine
• esegue i caratteri corrispondenti per carattere (anche per la punteggiatura)
• restituisce 1 per successo, 0 per errore

PHP

echo strrev($z)==$z;#;z$==)z$(verrts ohce

I fatti:

• $z stringa, la stringa di input da verificare
• $tbooleano, TRUE se la stringa di input $zè palindromo, altrimenti FALSE
• Uso dei commenti per aiutarmi a rendere il codice palindromo.
• Uscite $t
• La fonte stessa è un palindromo

Il motivo per cui non sarà possibile implementare il checker palindromo palindromo in PHP è perché le variabili PHP hanno un nome che inizia con a $. Non puoi terminare un nome identificativo con $in PHP.

PHP

<?php eval/*/*/(';{$i=fgets(STDIN,2e9);};{$a="strrev";}{var_dump("{$i}"=="{$a($i)}");}/*}{*\{;("{(tupni$)a$}"=="{putni$}")ohce}{;"verrts"==a$};{;(9e2,NIDTS)stegf=i$);');/*\*\eval php?>

Usa alcuni trucchi per evitare il $problema, tecnicamente non è un palindromo poiché alla fine ho dovuto intrufolarmi di soppiatto ;.

 <?php $i = fgets(STDIN,2e9); echo $i == strrev($i);/*\;(i$)verrts == i$ ohce ;(9e2, NIDTS)stegf = $i php?>

Questo è un lavoro che utilizza i /* */commenti di PHP e il fatto che non hai bisogno della fine per loro.

CoffeeScript

In realtà ho lottato con l'ortografia inversa di 'split', 'reverse' e 'join': \

p=(s)->s.split('').reverse().join('')==s#s==)''(nioj.)(esrever.)''(tilps.s>-)s(=p

Groovy

print args[0]==args[0].reverse()?1:0//0:1?)(esrever.]0[sgra==]0[sgra tnirp

Python 3, 55 byte

Utilizza un commento, ma è più breve dell'altro Python che utilizza commenti.

s=input();print(s==s[::-1])#)]1-::[s==s(tnirp;)(tupni=s

Fuzzy Octo Guacamole , 17 byte

^Cz.=i_;@;_i=.zC^

_{Non sono sicuro di come sia definita la vincita, ma ho messo il byte in alto.}

^ ottiene l'input e lo spinge al primo stack.

C copia il primo stack nel secondo.

z inverti la cima della pila, così "come" diventa "sa".

. sposta lo stack attivo, quindi lo stack attivo ha l'input e quello inattivo ha l'input invertito.

=controlla l'uguaglianza, ritornando 0per l'uguaglianza.

iinverte il ToS, così 0diventa 1, e qualsiasi altra cosa praticamente diventa False.

_apre e imposta la variabile temp che ;poi stampa.

@termina il programma manualmente, quindi non colpisce la parte invertita. Questo rende il palindromo.

Javascript

function a(b){return b==b.split('').reverse().join('')}//})''(nioj.)(esrever.)''(tilps.b==b nruter{)b(a noitcnuf

Difficile farlo senza commenti ...