Escreva um programa para testar se uma sequência é palindrômica, com a condição adicional de que o programa seja palindrômico.

Rubi

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

Imprime 1 se a entrada for um palíndromo, 0 se não for. Entrada sem quebra de linha.

Não usa nenhum comentário, mas usa dois truques:

• Curto-circuito: 0é true-ish no Ruby (apenas nile é falseavaliado como falso), portanto 1&&z==esrever.z* stupnão é avaliado e, portanto, não pode gerar uma exceção de tempo de execução
• O operador de splat / multiplicação ( *): Para evitar um erro de sintaxe z=esrever.z stup, forçamos o analisador a analisar isso como z=esrever.z()*stupadicionando a *. Por outro lado, o *é analisado como um operador de splat, que em uma chamada de função divide um array em uma série de parâmetros. Se existe apenas um elemento em vez de uma matriz, basicamente não faz nada, então puts *fooé equivalente a puts foo.

Solução óbvia usando comentários (imprime verdadeiro / falso):

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

Python sem comentário

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

Estou surpreso que ninguém tenha encontrado esse truque ainda, ele deve funcionar na maioria dos idiomas!

Perl

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

truques sem comentários, apenas abusando habilmente do operador de substituição (ei, variáveis ​​perl começam com $ também, e daí?)

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#

Exemplo em execução:

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

Golfscript

.-1%=#=%1-.

• apenas com truque de comentário
• entrada sem \ n no final
• executar char correspondente por char (mesmo para pontuação)
• retorna 1 para sucesso, 0 para falha

PHP

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

Fatos:

• $z string, a string de entrada para verificar
• $tbooleano, TRUE se a sequência de entrada $zfor palíndromo, FALSE caso contrário
• Usando comentários para me ajudar a tornar o código palíndromo.
• Saídas $t
• A própria fonte é um palíndromo

A razão pela qual não será possível implementar o verificador palíndromo palíndromo no PHP é porque as variáveis ​​PHP são nomeadas começando com a $. Você não pode terminar um nome de identificador com $no 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 alguns truques estranhos para evitar o $problema, tecnicamente não é um palíndromo, pois eu tive que me infiltrar ;no final.

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

Este é um trabalho que usa os /* */comentários do PHP e o fato de que você não precisa do fim para eles.

CoffeeScript

Na verdade, lutei com as grafias reversas de '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 bytes

Usa um comentário, mas é mais curto que o outro Python que usa comentários.

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

Fuzzy Octo Guacamole , 17 bytes

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

_{Não sei exatamente como a vitória está definida, mas eu coloco a contagem de bytes no topo.}

^ obtém a entrada e a envia para a primeira pilha.

C copia a primeira pilha para a segunda.

z inverta a parte superior da pilha, para que "as" se torne "sa".

. muda a pilha ativa, para que a pilha ativa tenha a entrada e a inativa a entrada reversa.

=verifica a igualdade, retornando 0à igualdade.

iinverte os ToS, 0torna - se 1, e qualquer outra coisa se torna False.

_aparece e define a variável temp que é ;impressa.

@finaliza o programa manualmente, para não atingir a parte invertida. Isso faz o palíndromo.

Javascript

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

Difícil de fazer isso sem comentários ...