Houve algumas tentativas anteriores de fazer essa pergunta, mas nenhuma delas está em conformidade com os padrões modernos deste site. Por discussão sobre o Meta , estou reposicionando-o de uma maneira que permita uma concorrência justa de acordo com nossos modernos conjuntos de regras.

fundo

Um palíndromo é uma sequência que "lê o mesmo para a frente e para trás", ou seja, o reverso da sequência é o mesmo que a própria sequência. Não estamos falando de "palíndromos convenientes" aqui, mas de uma estrita inversão caractere a caractere; por exemplo, ()()não é um palíndromo, mas ())(é.

A tarefa

Escreva um programa ou função que use uma string S (ou o equivalente apropriado no seu idioma) como entrada e tenha uma saída Q (de um tipo de sua escolha). Você pode usar qualquer meio razoável para receber a entrada e fornecer a saída.

• Quando a entrada S é um palíndromo, a saída Q deve ter um valor A (que é o mesmo para qualquer palíndromo S ).
• Quando a entrada S não é um palíndromo, a saída Q deve ter um valor B (que é o mesmo para qualquer S não palíndrico ).
• A e B devem ser distintos um do outro.

Ou seja: mapeie todos os palíndromos para um valor e todos os não palíndromos para outro.

Além disso, o programa ou função que você escreve deve ser um palíndromo em si (ou seja, seu código-fonte deve ser palíndrico), tornando este um desafio de fonte restrita .

Esclarecimentos

• Embora truee falsesão escolhas óbvias para A e B , você pode usar quaisquer dois valores distintos para o seu "é um palíndromo" e "não é um palíndromo" saídas, que não precisa ser booleans.
• Estamos definindo a reversão de cadeia no nível do caractere aqui; ééé palíndrico, independentemente de o programa estar codificado em UTF-8 ou Latin-1, mesmo que não seja uma sequência palindrômica de octetos após a codificação UTF-8.
• No entanto, mesmo que seu programa contenha caracteres não ASCII, ele precisará trabalhar apenas para entrada ASCII. Especificamente, a entrada S conterá apenas caracteres ASCII imprimíveis (incluindo espaço, mas não incluindo nova linha). Entre outras coisas, isso significa que, se você tratar a entrada como uma sequência de bytes, e não como uma sequência de caracteres, seu programa provavelmente ainda estará em conformidade com a especificação (a menos que a codificação de E / S do seu idioma seja muito estranha). Como tal, a definição de um palíndromo no item anterior realmente importa apenas quando se verifica se o programa possui a forma correta.
• Ocultar metade do programa em um comentário ou literal de string, apesar de não ser criativo, é legal; você está sendo pontuado no comprimento, não na criatividade; portanto, sinta-se à vontade para usar métodos "chatos" para garantir que seu programa seja um palíndromo. É claro que, como você está sendo pontuado no comprimento, partes do seu programa que não fazem nada pioram sua pontuação; portanto, poder usar as duas partes do seu programa provavelmente será útil se você puder gerenciá-lo. .
• Como o critério de vitória é medido em bytes, você precisará especificar a codificação na qual seu programa foi gravado para poder pontuá-lo (embora em muitos casos seja óbvio qual codificação você está usando).

Critério de vitória

Mesmo que o programa precise ser um palíndromo no nível do personagem, estamos usando bytes para ver quem ganha. Especificamente, quanto mais curto for o seu programa, medido em bytes, melhor; este é um desafio do código-golfe . Para permitir a comparação de envios (especialmente envios no mesmo idioma), coloque uma contagem de bytes para o seu programa no cabeçalho do envio (mais uma contagem de caracteres, se for diferente do número de bytes).

Brachylog (2), 3 bytes na página de códigos de Brachylog

I↔I

Experimente online!

Este é um programa completo que recebe entradas via entrada padrão (usando a sintaxe de Brachylog para constantes, ou seja, as cadeias são colocadas entre aspas duplas) e sai via saída padrão. As saídas são true.para uma entrada palindrômica e false.para uma entrada não palindrômica.

Este programa não é apenas palindrômico, mas também possui simetria no espelho esquerdo / direito (e provavelmente em algumas fontes para cima / para baixo).

Explicação

No Brachylog, as letras maiúsculas marcam pontos no programa que têm valores idênticos; isso é usado quase como um circuito elétrico para transportar informações de uma parte do programa para outra. Uma conseqüência disso é que, se você incluir um comando entre um par idêntico de letras maiúsculas, estará efetivamente afirmando que a entrada e a saída do comando são as mesmas. O Brachylog aceita implicitamente a entrada, portanto, neste caso, também estamos afirmando que a entrada do comando é a mesma que a entrada do programa. Neste programa, estamos usando o comando ↔, que inverte as coisas (neste caso, strings); portanto, o programa efetivamente afirma que a entrada é a mesma para frente e para trás.

Um programa completo (em oposição a uma função) no Brachylog retorna um booleano, false.se não houver maneira de corrigir todas as asserções do programa de uma só vez, ou true.se as asserções do programa forem compatíveis entre si. Temos apenas uma afirmação aqui - que a reversão da entrada não a altera -, portanto, o programa atua como um verificador palíndromo.

Pitão , 3 bytes

_I_

Retorna Verdadeiro ou Falso .

Experimente online!

Como funciona

  _  Reverse the input.
_I   Invariant-reverse; test if the reversed input is equal to its reverse.

Python , 39 bytes

lambda s:s[::-1]==s#s==]1-::[s:s adbmal

Experimente online!

Chato, mas se houver mais curto em Python, será impressionante.

Gelatina , 5 bytes

ḂŒ
ŒḂ

Retorna 1 ou 0 . A primeira linha é um link auxiliar não executado, a segunda linha chama o teste palíndromo.

Experimente online!

Gelatina , 5 bytes

⁼ṚaṚ⁼

Experimente online!

É igual a reverso e reverso é igual.

Ou o mais eficiente e menos esteticamente agradável:

⁼Ṛ
Ṛ⁼

ou

Ṛ⁼
⁼Ṛ

Mathematica, 23 bytes

QemordnilaP;PalindromeQ

Não é muito interessante, mas por uma questão de perfeição ...

O acima é um CompoundExpressionque avalia PalindromeQ, um interno que resolve o desafio. QemordnilaPé simplesmente um identificador indefinido, que é ignorado por causa do ;.

Haskell, 87 85 44 34 bytes

p=(==)<*>reverse--esrever>*<)==(=p

Explicação: ((->) a)é uma instância de Applicative (obrigado @faubiguy), <*>definida como

(<*>) f g x = f x (g x)

Assim, substituindo nos argumentos, pode-se ver por que isso funciona.

05AB1E , 3 bytes

Código:

ÂQÂ

Explicação:

     # Bifurcate (duplicate and reverse the duplicate) implicit input
 Q    # Check if equal
  Â   # Bifurcate the result

Usa a codificação CP-1252 . Experimente online!

PHP, 55 bytes

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

Além disso, o nome do idioma é um palíndromo, então ... pontos de bônus!

MATL , 7 bytes

tPX=XPt

Experimente online!

Retorna [1; 1] para entrada palíndrica e [0; 0] caso contrário.

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

Pip , 12 11 bytes

Agora sem comentários!

x:RVaQaVR:x

Recebe entrada como um argumento de linha de comando; saídas 1para palíndromo, 0para não palíndromo. Experimente online!

O núcleo do que queremos fazer é RVaQa: reverse(a) string-equals a. O código x:RVaQacalcula esse resultado e o atribui x. Em seguida, VR:xatribui o valor xà variável VR. Como essa atribuição é a última instrução do programa, seu valor também é impresso automaticamente. Voila!

Para uma versão interessante anterior usando algum comportamento indefinido, consulte o histórico de revisões.

Perl 6 , 25 bytes / caracteres utf8

{.flip eq$_}#}_$qe pilf.{

Tente

R, 111 103 bytes

all((s<-el(strsplit(scan(,"",,,"\n"),"")))==rev(s))#))s(ver==)))"",)"n\",,,"",(nacs(tilpsrts(le-<s((lla

Não é a resposta mais original. #é o caractere de comentário em R

Ungolfed:

all((s<-el(strsplit(scan(,"",,,"\n"),"")))==rev(s))
#
))s(ver==)))"",)"n\",,,"",(nacs(tilpsrts(le-<s((lla

A cadeia de caracteres de scané convertida em bytes brutos, graças à charToRawfunção Esses bytes brutos são comparados um a um aos seus equivalentes da rev()função, que reverte a ordem do seu argumento. A saída desta parte é um vetor de TRUEe / ou FALSE.
A allfunção então gera TRUEse todos esses elementos foremTRUE

Aqui, "\n"na scanfunção é necessário para entradas com mais de uma palavra.

Resposta anterior (em bytes), 81 bytes

function(s)all((s=charToRaw(s))==rev(s))#))s(ver==))s(waRoTr‌​ahc=s((lla)s(noitcnu‌​f

com - 24 bytes graças a @rturnbull .

RProgN , 11 bytes

~]S.E E.S]~

A primeira metade disso faz todo o trabalho pesado e, por uma conveniência do RProgN, a segunda metade é um 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.

Experimente online!

Retina , 53 bytes

A contagem de bytes assume a codificação ISO 8859-1.

$
¶$`
O$^`\G.
»
D`
M$`^.+$
$+.^`$M
`D
»
.G\`^$O
`$¶
$

Experimente online!

Tenho certeza de que isso ainda não é o ideal (a »linha parece particularmente esbanjadora e eu tenho uma solução de 45 bytes palindrômica, exceto um caractere), mas acho que é um começo.

GNU sed , 64 59 + 1 (sinalizador r) = 60 bytes UTF-8

Demorei um pouco para encontrar uma resposta sed que não usasse uma seção de comentários para tornar o código um palíndromo. Em vez disso, eu uso o ccomando que imprimiria a primeira metade do código na ordem inversa, apenas garanto que esta instrução não seja alcançada.

:;s:^(.)(.*)\1$:\2:;t;/../c1
d
1c/../;t;:2\:$1\)*.().(^:s;:

O script será impresso 1se a sequência de entrada não for um palíndromo (pense nisso como um erro). Se a string for um palíndromo, nenhuma saída será fornecida (pense nela como saindo com êxito).

Execute exemplos: ou Experimente online!

me@LCARS:/PPCG$ sed -rf palindrome_source.sed <<< "level"
me@LCARS:/PPCG$ sed -rf palindrome_source.sed <<< "game"
1

Explicação:

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

Alice , 19 bytes

/@.nzRoi\
\ioRzn.@/

Experimente online!

Imprime Jabberwockypara palíndromos e nada para não-palíndromos. Funciona para entrada UTF-8 arbitrária.

Explicação

Como essa é uma tarefa de processamento de cadeia, Alice terá que operar no modo Ordinal para resolvê-la. Isso, por sua vez, significa que o ponteiro da instrução precisa se mover na diagonal e, portanto, precisamos de pelo menos duas linhas para que o IP possa saltar para cima e para baixo. O avanço de linha nesse programa contribui para uma boa posição para colocar o caractere do meio do palíndromo. Isso significa que a segunda linha precisa ser o inverso da primeira. Mas como estamos executando apenas todos os outros caracteres em cada linha, se tivermos certeza de que o comprimento da linha é ímpar, o inverso do código se ajustará perfeitamente às suas próprias lacunas. O único caractere que não é usado é a barra invertida, mas, como foi arbitrária, eu a escolhi para tornar o programa bonito e simétrico.

De qualquer forma, o código relevante é este:

/ . z o
 i R n @

Que é executado em zigue-zague da esquerda para a direita.

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

Haskell , 34 bytes

f=(==)=<<reverse--esrever<<=)==(=f

Experimente online! Ligue com f "some string", retorna Trueou False.

O =<<operador em funções funciona assim f=<<g = \s -> f (g s) s, então o código é equivalente a f s=s==reverse s, o qual, como acabei de notar, resultaria na mesma contagem de bytes.

Versão sem comentário: (49 bytes)

e x y=x/=y
p=e=<<reverse
esrever<<=e=p
y=/x=y x e

Experimente online!

Ligue com p "some string". Isso gera False, se a string dada é um palíndromo, e Truese é não um palíndromo.

Explicação:

Encontrei esse palíndromo livre de comentários começando com a versão do comentário e substituindo o comentário por uma nova linha:

p=(==)=<<reverse
esrever<<=)==(=p

A segunda linha falha porque os parênteses não coincidem, portanto, precisamos nos livrar deles. Se tivéssemos uma função eque verifica a igualdade, então

p=e=<<reverse
esrever<<=e=p

será tanto compilar com a segunda linha que define uma infixa-operador <<=que leva dois argumentos esrevere ee retorna a função p.

Para definir ecomo a função de igualdade, normalmente se escreveria e=(==), mas )==(=enovamente não será compilado. Em vez disso, poderia levar explicitamente dois argumentos e passá-las para ==: e x y=x==y. Agora, o código invertido y==x=y x ecompila, mas redefine o ==operador, causando e x y=x==yfalha na definição . No entanto, se mudarmos para o operador de desigualdade /=, a definição invertida se torna y=/x=y x ee define um =/operador que não interfere no /=operador original .

ÓLEO , 178 bytes

Lê uma entrada, explode, adiciona lentamente seu comprimento (por meio de incrementos e decrementos) ao endereço para saber o endereço após a string, pula para uma parte diferente do código (no meio), inverte a direção da banda, implode a string novamente e verifica se é igual à string original. TL; DR: É uma dor, como sempre.

Saída 40se a sequência não for um palíndromo, 0se for.

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

Javascript, 64 bytes

f=s=>s==[...s].reverse().join``//``nioj.)(esrever.]s...[==s>=s=f

Chamar função fcom string

f("abba") // returns true
f("abab") // returns false

Japonês , 7 2 bytes

êê

Executá-lo

Solução antiga:

U¥UwU¥U

Experimente online!

Explicação

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 não escapa funções, a menos que um parêntese de fechamento (ou espaço) seja alcançado.

Isso pode ser reescrito: U¥Uw(U¥U)→ U¥Uw→ U==Uw. No Japt, o parêntese deixado de fora no início e no final de uma função é inserido automaticamente.

Utilitários Bash + Unix, 49 bytes

[ "$1" = "`rev<<<$1`" ] # ] "`1$<<<ver`" = "1$" [

A entrada é passada como argumento.

A saída é retornada no código do resultado - 0 para um palíndromo, 1 para um não-palíndromo.

Talvez alguém possa fazer melhor e não apenas confiar em um comentário para tornar o código palindrômico.

Experimente online!

> <>, 11 bytes

{=?!;
;!?={

Experimente aqui!

Retorna "\ nalgo cheira a peixe ..." em um palíndromo válido, nenhuma saída em um palíndromo inválido. Coloque o palíndromo na pilha.

Java - 171 169 160 bytes

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

O comentário no final é torná-lo um palíndromo. Retorna P(alindrome)quando a entrada é palíndromo e N(ot)quando não.

Versão não destruída:

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 bytes salvos graças ao @DLosc

Agradecemos a @Olivier Grégoire por apontar a quantidade incorreta de bytes! Corrigido agora

Java 8, 92 90 bytes

Esta é uma versão de comentário. Se uma string contém seu reverso, é um palíndromo ( true), caso contrário não é ( false).

s->s.contains(new StringBuffer(s).reverse())//))(esrever.)s(reffuBgnirtS wen(sniatnoc.s>-s

Experimente online!

Atualizar

• -2 [18-04-05] Comutado para contém. Obrigado a @Kevin Cruijssen !
• -2 [17-02-20] Removeu ;'s
• -16 [17-02-22] Conversão automática

Na verdade , 5 bytes

;R=R;

Experimente online!

A saída [1]\n[1]verdadeira é e a saída falsey é []\n[](em ambas as saídas, \nrepresenta uma nova linha literal).

Explicação:

;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

C ++, 154 bytes

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 dizer que a afirmação inversa foi cara, mas não consigo imaginar muito que possa fazer para mudar isso. Ser capaz de cortar os símbolos std :: me salvaria em torno de 10 caracteres, mas "usando o namespace std;" é muito mais.

Suponho que C ++ não foi realmente feito para ser breve.

Prolog, 44 bytes

p-->[]|[_]|[E],p,[E].%.]E[,p,]E[|]_[|][>--p

Isso usa gramáticas de cláusulas definidas. Na verdade, é uma gramática livre de contexto 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.

CJam, 13 bytes

l_W%=e#e=%W_l

Explicação:

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

Exemplo:

> 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

J, 15 bytes, 15 caracteres

-:|.NB. .BN.|:-

Retorna 1 se palíndromo, 0 se não.

Resultado:

   f '())('
1
   f 'nope'
0

Explicação:

-:    NB. "Match" verb, checks for equality
|.    NB. Reverses the string