Escriba un programa para probar si una cadena es palindrómica, con la condición adicional de que el programa sea palindrómico.

Rubí

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

Imprime 1 si la entrada es un palíndromo, 0 si no lo es. Entrada sin salto de línea.

No usa ningún comentario, en su lugar usa 2 trucos:

• Cortocircuito: 0es verdadero-ish en Ruby (solo nily falseevaluar como falso), por 1&&z==esrever.z* stuplo que no se evalúa y, por lo tanto, no puede generar una excepción de tiempo de ejecución
• El operador splat / multiplication ( *): para evitar un error de sintaxis z=esrever.z stup, forzamos al analizador a analizar esto z=esrever.z()*stupal agregar a *. Por otro lado, *se analiza como un operador splat, que en una llamada a la función divide una matriz en una serie de parámetros. Si solo hay un elemento en lugar de una matriz, básicamente no hace nada, por lo que puts *fooes equivalente a puts foo.

Solución obvia usando comentarios (imprime verdadero / falso):

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

Python sin comentarios

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

Me sorprende que nadie haya encontrado ese truco todavía, ¡debería funcionar en la mayoría de los idiomas!

Perl

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

sin trucos de comentarios, solo abusando hábilmente del operador de sustitución (bueno, las variables perl también comienzan con $, ¿y qué?)

Python 2.7

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

do

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

Ejecutando ejemplo:

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

Golfscript

.-1%=#=%1-.

• solo con truco de comentarios
• entrada sin \ n al final
• realizar coincidencia de caracteres por caracteres (incluso para la puntuación)
• devuelve 1 para el éxito, 0 para el fracaso

PHP

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

Hechos:

• $z string, la cadena de entrada para verificar
• $t boolean, TRUE si la cadena de entrada $z es palíndromo, FALSO de lo contrario
• Usando comentarios para ayudarme a hacer el código palíndromo.
• Salidas $t
• La fuente misma es un palíndromo

La razón por la cual no será posible implementar el verificador de palíndromo palindrómico en PHP es porque las variables de PHP se nombran comenzando con a $. No puede finalizar un nombre de identificador con $en 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?>

Utiliza algunos trucos extraños para evitar el $problema, técnicamente no es un palíndromo ya que tuve que introducirlo ;al final.

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

Este es un trabajo que utiliza los /* */comentarios de PHP y el hecho de que no necesita el final para ellos.

CoffeeScript

En realidad luché con la ortografía inversa de 'split', 'reverse' y 'join': \

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

Maravilloso

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

Python 3, 55 bytes

Utiliza un comentario, pero es más corto que el otro Python que utiliza comentarios.

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

Fuzzy Octo Guacamole , 17 bytes

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

_{No estoy seguro de cómo se define la victoria, pero puse el conteo de bytes en la parte superior.}

^ obtiene la entrada y la empuja a la primera pila.

C copia la primera pila a la segunda.

z invierta la parte superior de la pila, de modo que "as" se convierta en "sa".

. desplaza la pila activa, de modo que la pila activa tiene la entrada y la inactiva tiene la entrada invertida.

=comprueba la igualdad, volviendo 0por la igualdad.

iinvierte el ToS, entonces se 0convierte 1, y cualquier otra cosa se convierte prácticamente False.

_aparece y establece la variable temporal que ;luego imprime.

@finaliza el programa manualmente, por lo que no golpea la parte invertida. Esto hace que el palíndromo.

Javascript

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

Difícil hacerlo sin comentarios ...