Ecrivez un programme pour tester si une chaîne est palindromique, avec la condition supplémentaire que le programme soit lui-même palindromique.

Rubis

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

Imprime 1 si l'entrée est un palindrome, 0 si ce n'est pas le cas. Entrée sans saut de ligne.

N'utilise aucun commentaire, mais utilise 2 astuces:

• Short-circuiting: 0true-ish en Ruby (seulement nilet falseévalué à false), 1&&z==esrever.z* stupn'est donc pas évalué et ne peut donc pas déclencher d'exception d'exécution
• L'opérateur splat / multiplication ( *): Pour éviter une erreur de syntaxe z=esrever.z stup, nous forçons l'analyseur à l'analyser z=esrever.z()*stupen ajoutant un *. De l'autre côté, l' *opérateur est analysé comme un opérateur splat qui, dans un appel de fonction, divise un tableau en une série de paramètres. S'il n'y a qu'un seul élément au lieu d'un tableau, cela ne fait fondamentalement rien, donc puts *fooéquivaut à puts foo.

Solution évidente à l'aide de commentaires (affiche vrai / faux):

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

Python sans commentaire

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

Je suis surpris que personne n'ait encore trouvé ce truc, il devrait fonctionner dans la plupart des langues!

Perl

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

pas de commentaires astucieux, juste abuser intelligemment de l'opérateur de substitution (hé, les variables perl commencent par un $ aussi, alors quoi?)

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#

Exemple en cours d'exécution:

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

Golfscript

.-1%=#=%1-.

• juste avec un tour de commentaire
• entrée sans \ n à la fin
• faire correspondre caractère par caractère (même pour la ponctuation)
• renvoie 1 en cas de succès, 0 en cas d'échec

PHP

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

Les faits:

• $z string, la chaîne d'entrée à vérifier
• $tboolean, TRUE si la chaîne d'entrée $zest palindrome, FALSE sinon
• Utilisation de commentaires pour m'aider à créer le code palindrome.
• Les sorties $t
• La source elle-même est un palindrome

La raison pour laquelle il ne sera pas possible d’implémenter le vérificateur de palindrome palindrome en PHP c’est parce que les variables PHP sont nommées en commençant par a $. Vous ne pouvez pas terminer un identifiant avec $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?>

Utilise quelques astuces étranges pour éviter le $problème, techniquement, ce n’est pas un palindrome, car j’ai dû me faufiler ;à la fin.

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

C’est un système qui utilise les /* */commentaires de PHP et le fait que vous n’avez pas besoin de la fin.

CoffeeScript

En fait, j'ai eu du mal avec les orthographes inversées de 'split', 'reverse' et 'join': \

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

Sensationnel

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

Python 3, 55 octets

Utilise un commentaire, mais est plus court que l’autre Python qui utilise des commentaires.

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

Fuzzy Octo Guacamole , 17 octets

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

_{Je ne sais pas exactement comment la victoire est définie, mais j'ai mis le nombre d'octets en haut.}

^ obtient l'entrée et la pousse à la première pile.

C copie la première pile dans la seconde.

z inverser le haut de la pile, de sorte que "comme" devienne "sa".

. décale la pile active, de sorte que la pile active ait l'entrée, et l'inactive, l'entrée inversée.

=vérifie l'égalité, retourne 0pour l'égalité.

iInverse le ToS, ainsi 0devient 1, et toute autre chose devient pratiquement False.

_apparaît et définit la variable temp qui est ;ensuite imprimée.

@termine le programme manuellement pour ne pas toucher la partie inversée. Cela rend le palindrome.

Javascript

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

Difficile de le faire sans commentaires ...