Ha habido un par de intentos anteriores para hacer esta pregunta, pero ninguno se ajusta a los estándares modernos en este sitio. Según el debate sobre Meta , lo vuelvo a publicar de una manera que permita una competencia leal bajo nuestros modernos conjuntos de reglas.

Antecedentes

Un palíndromo es una cadena que "lee lo mismo hacia adelante y hacia atrás", es decir, el reverso de la cadena es el mismo que la cadena misma. No estamos hablando de "palíndromos convenientes" aquí, sino de una inversión estricta de carácter por carácter; por ejemplo, ()()no es un palíndromo, pero lo ())(es.

La tarea

Escriba un programa o función que tome una cadena S (o el equivalente apropiado en su idioma) como entrada, y tenga una salida Q (del tipo que elija). Puede utilizar cualquier medio razonable para tomar la entrada y proporcionar la salida.

• Cuando la entrada S es un palíndromo, la salida Q debe tener un valor A (que es el mismo para cualquier S palindrómico ).
• Cuando la entrada S no es un palíndromo, la salida Q debe tener un valor B (que es el mismo para cualquier S no palindrómico ).
• A y B deben ser distintos entre sí.

O en otras palabras: mapear todos los palíndromos a un valor, y todos los no palíndromos a otro.

Además, el programa o función que escriba debe ser un palíndromo en sí mismo (es decir, su código fuente debe ser palindrómico), lo que lo convierte en un desafío de fuente restringida .

Aclaraciones

• Aunque truey falseson opciones obvias para A y B , puede usar dos valores distintos para sus salidas "es un palíndromo" y "no es un palíndromo", que no necesitan ser booleanos.
• Aquí estamos definiendo la inversión de cadena a nivel de personaje ; éées palindrómico independientemente de si el programa está codificado en UTF-8 o Latin-1, a pesar de que no es una secuencia palindrómica de octetos después de la codificación UTF-8.
• Sin embargo, incluso si su programa contiene caracteres no ASCII, solo necesita trabajar para la entrada ASCII. Específicamente, la entrada S solo contendrá caracteres ASCII imprimibles (incluido el espacio, pero no la nueva línea). Entre otras cosas, esto significa que si trata la entrada como una secuencia de bytes en lugar de una secuencia de caracteres, es probable que su programa cumpla con la especificación (a menos que la codificación de E / S de su idioma sea muy extraña). Como tal, la definición de un palíndromo en la viñeta anterior solo importa cuando se verifica que el programa tenga la forma correcta.
• Ocultar la mitad del programa en un comentario o cadena literal, sin ser creativo, es legal; se te califica por la longitud, no por la creatividad, así que siéntete libre de usar métodos "aburridos" para asegurarte de que tu programa sea un palíndromo. Por supuesto, debido a que su puntaje se basa en la duración, las partes de su programa que no hacen nada empeorarán su puntaje, por lo que poder usar ambas mitades de su programa probablemente sea útil si puede manejarlo. .
• Debido a que el criterio de victoria se mide en bytes, deberá especificar la codificación en la que está escrito su programa para poder calificarlo (aunque en muchos casos será obvio qué codificación está usando).

Criterio de victoria

Aunque el programa necesita ser un palíndromo a nivel de personaje, estamos usando bytes para ver quién gana. Específicamente, cuanto más corto sea su programa, medido en bytes, mejor; Este es un desafío de código de golf . Para permitir que se comparen los envíos (especialmente los envíos en el mismo idioma), coloque un recuento de bytes para su programa en el encabezado de su envío (más un recuento de caracteres, si difiere del número de bytes).

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

I↔I

Pruébalo en línea!

Este es un programa completo que toma la entrada a través de la entrada estándar (usando la sintaxis de Brachylog para constantes, es decir, las cadenas están entre comillas dobles) y las salidas a través de la salida estándar. Las salidas son true.para una entrada palindrómica y false.para una entrada no palindrómica.

Este programa no solo es palindrómico, sino que también tiene simetría de espejo izquierda / derecha (y probablemente en algunas fuentes arriba / abajo).

Explicación

En Brachylog, las letras mayúsculas marcan puntos en el programa que tienen valores idénticos; esto se usa casi como un circuito eléctrico para transportar información de una parte del programa a otra. Una consecuencia de esto es que si encierra un comando entre un par idéntico de letras mayúsculas, efectivamente está afirmando que la entrada y la salida del comando son las mismas. Brachylog toma entrada implícitamente, por lo que en este caso también estamos afirmando que la entrada al comando es la misma que la entrada al programa. En este programa, estamos usando el comando ↔, que invierte las cosas (en este caso, cadenas); entonces el programa efectivamente afirma que la entrada es la misma hacia adelante y hacia atrás.

Un programa completo (en oposición a una función) en Brachylog devuelve un valor booleano, false.si no hay forma de hacer que todas las aserciones en el programa sean correctas a la vez, o true.si las aserciones en el programa son compatibles entre sí. Aquí solo tenemos una afirmación: que invertir la entrada no la cambia, por lo que el programa actúa como un verificador de palíndromo.

Pyth , 3 bytes

_I_

Devuelve verdadero o falso .

Pruébalo en línea!

Cómo 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

Pruébalo en línea!

Aburrido, pero si hay Python más corto será impresionante.

Jalea , 5 bytes

ḂŒ
ŒḂ

Devuelve 1 o 0 . La primera línea es un enlace auxiliar no ejecutado, la segunda línea llama a la prueba de palíndromo.

Pruébalo en línea!

Jalea , 5 bytes

⁼ṚaṚ⁼

Pruébalo en línea!

Es igual a reversa e inversa a igual.

O el más eficiente pero menos estéticamente agradable:

⁼Ṛ
Ṛ⁼

o

Ṛ⁼
⁼Ṛ

Mathematica, 23 bytes

QemordnilaP;PalindromeQ

No muy interesante, pero en aras de la integridad ...

Lo anterior es un CompoundExpressionque se evalúa como PalindromeQun incorporado que resuelve el desafío. QemordnilaPes simplemente un identificador indefinido, que se ignora debido a ;.

Haskell, 87 85 44 34 bytes

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

Explicación: ((->) a)es una instancia de aplicativo (gracias @faubiguy), con <*>definido como

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

Entonces, sustituyendo en los argumentos uno puede ver por qué esto funciona.

05AB1E , 3 bytes

Código:

ÂQÂ

Explicación:

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

Utiliza la codificación CP-1252 . Pruébalo en línea!

PHP, 55 bytes

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

Además, el nombre del idioma es un palíndromo, así que ... ¡puntos extra!

MATL , 7 bytes

tPX=XPt

Pruébalo en línea!

Devuelve [1; 1] para entrada palindrómica y [0; 0] de lo contrario.

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

Ahora sin comentarios!

x:RVaQaVR:x

Toma entrada como un argumento de línea de comando; salidas 1para palíndromo, 0para no palíndromo.Pruébalo en línea!

El núcleo de lo que queremos hacer es RVaQa: reverse(a) string-equals a. El código x:RVaQacalcula este resultado y se lo asigna x. Luego VR:xasigna el valor de xa la variable VR. Dado que esta asignación es la última instrucción del programa, su valor también se imprime automáticamente. Voila!

Para ver una versión interesante anterior que utiliza un comportamiento indefinido, consulte el historial de revisiones.

Perl 6 , 25 bytes / caracteres utf8

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

Intentalo

R, 111103 bytes

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

No es la respuesta más original. #es el carácter de comentario en R

Sin golf:

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

La cadena de caracteres de scanse convierte en bytes sin formato gracias a la charToRawfunción. Estos bytes sin procesar se comparan uno por uno con sus contrapartes de la rev()función, que invierte el orden de su argumento. La salida de esta parte es un vector de TRUEy / o FALSE.
La allfunción luego emiteTRUE si todos esos elementos sonTRUE

Aquí, "\n" en la scanfunción es necesario para entradas con más de una palabra.

Respuesta anterior (byte-wise), 81 bytes

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

con - 24 bytes gracias a @rturnbull .

RProgN , 11 bytes

~]S.E E.S]~

La primera mitad de esto hace todo el trabajo pesado, y por conveniencia de RProgN, la segunda mitad es un 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.

Pruébalo en línea!

Retina , 53 bytes

El recuento de bytes asume la codificación ISO 8859-1.

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

Pruébalo en línea!

Estoy bastante seguro de que esto aún no es óptimo (la »línea parece particularmente derrochadora, y tengo una solución de 45 bytes que es palindrómica, excepto por un personaje), pero supongo que es un comienzo.

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

Me tomó un tiempo encontrar una respuesta sed que no esté usando una sección de comentarios para convertir el código en un palíndromo. En cambio, uso el ccomando que imprimiría la primera mitad del código en orden inverso, solo me aseguro de que no se alcance esta instrucción.

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

El script se imprime 1si la cadena de entrada no es un palíndromo (considérelo como un error). Si la cadena es un palíndromo, entonces no se da salida (piense en ella como si se hubiera salido con éxito).

Ejecute ejemplos: o ¡ Pruébelo en línea!

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

Explicación:

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

Pruébalo en línea!

Huellas dactilares Jabberwocky para palíndromos y nada para los no palíndromos. Funciona para entradas arbitrarias UTF-8.

Explicación

Como se trata de una tarea de procesamiento de cadenas, Alice tendrá que operar en modo ordinal para resolverlo. Eso a su vez significa que el puntero de instrucciones tiene que moverse en diagonal y, por lo tanto, necesitamos al menos dos líneas para que la IP pueda rebotar hacia arriba y hacia abajo. El avance de línea en dicho programa lo convierte en una buena posición para colocar el carácter medio del palíndromo. Eso significa que la segunda línea debe ser la inversa de la primera. Pero como solo estamos ejecutando todos los demás caracteres en cada línea, si nos aseguramos de que la longitud de la línea sea impar, el reverso del código encajará perfectamente en sus propios espacios. El único carácter que no se usa en absoluto es la barra diagonal inversa, pero como era arbitrario, lo elegí para que el programa se viera agradable y simétrico.

De todos modos, el código relevante real es este:

/ . z o
 i R n @

El cual se ejecuta en zigzag de izquierda a derecha.

/   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

Pruébalo en línea! Llamar con f "some string", devoluciones Trueo False.

El =<<operador en funciones funciona de manera similar f=<<g = \s -> f (g s) s, por lo que el código es equivalente a f s=s==reverse s, lo que, como acabo de notar, daría como resultado el mismo recuento de bytes.

Versión sin comentario: (49 bytes)

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

Pruébalo en línea!

Llamada con p "some string". Esto salidasFalse si la cadena dada es un palíndromo, y Truesi es no un palíndromo.

Explicación:

Encontré este comentario libre de palíndromo comenzando con la versión del comentario y reemplazando el comentario con una nueva línea:

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

La segunda línea falla porque los paréntesis no coinciden, por lo que debemos deshacernos de ellos. Si tuviéramos una funcióne que verificara la igualdad, entonces

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

ambos compilarán con la segunda línea que define un operador infijo <<=que toma dos argumentosesrever ye y devuelve la función p.

Para definir ecomo la función de igualdad, normalmente se escribiría e=(==), pero )==(=enuevamente no se compilará. En vez podríamos tener explícitamente dos argumentos y pasarlos a ==: e x y=x==y. Ahora el código invertido se y==x=y x ecompila pero redefine al ==operador, lo que hace que la definición e x y=x==yfalle. Sin embargo, si cambiamos al operador de desigualdad /=, la definición inversa se convierte y=/x=y x ey define un =/operador que no interfiere con el /=operador original .

ACEITE , 178 bytes

Lee una entrada, la explota, agrega lentamente su longitud (a través del incremento y la disminución) a la dirección para conocer la dirección después de la cadena, salta a una parte diferente del código (en el medio), invierte la dirección de la banda, implosiona la cadena nuevamente, y comprueba si es lo mismo que la cadena original. TL; DR: Es un dolor, como siempre.

Salidas 40si la cadena no es un palíndromo, 0si lo es.

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

Función de llamada fcon cadena

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

Japt , 7 2 bytes

êê

Ejecutarlo

Vieja solución:

U¥UwU¥U

Pruébalo en línea!

Explicación

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 no escapa de las funciones a menos que se llegue a un paréntesis de cierre (o espacio).

Esto puede reescribirse: U¥Uw(U¥U)→ U¥Uw→ U==Uw. En Japt, el paréntesis dejado al principio y al final de una función se inserta automáticamente.

Bash + Unix utilities, 49 bytes

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

La entrada se pasa como argumento.

La salida se devuelve en el código de resultado: 0 para un palíndromo, 1 para un no palíndromo.

Quizás alguien pueda hacerlo mejor y no solo confiar en un comentario para hacer que el código sea palindrómico.

Pruébalo en línea!

> <>, 11 bytes

{=?!;
;!?={

Pruébalo aquí!

Devuelve "\ nalgo huele a pescado ..." en un palíndromo válido, sin salida en un palíndromo no válido. Coloque el palíndromo en la pila.

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

El comentario al final es convertirlo en un palíndromo. Devuelve P(alindrome)cuando la entrada es palíndromo y N(ot)cuando no.

Versión sin golf:

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 guardados gracias a @DLosc

¡Gracias a @Olivier Grégoire por señalar la cantidad incorrecta de bytes! Arreglado ahora

Java 8, 92 90 bytes

Esta es una versión de comentario. Si una cadena contiene su reverso, entonces es un palíndromo ( true) de lo contrario no lo es ( false).

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

Pruébalo en línea!

Actualizar

• -2 [18-04-05] Cambiado a contiene. Gracias a @Kevin Cruijssen !
• -2 [17-02-20] Eliminado; 's
• -16 [17-02-22] Conversión automática

En realidad , 5 bytes

;R=R;

Pruébalo en línea!

La salida verdadera es [1]\n[1], y la salida falsey es []\n[](en ambas salidas, \nrepresenta una nueva línea literal).

Explicación:

;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

Tengo que decir que la declaración inversa fue costosa, pero no puedo imaginar mucho que pueda hacer para cambiar eso. Ser capaz de cortar los símbolos std :: me ahorraría alrededor de 10 caracteres, pero "usar el espacio de nombres std;" son bastantes más

Supongo que C ++ no estaba realmente destinado a la brevedad.

Prólogo, 44 ​​bytes

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

Esto usa gramáticas de cláusulas definidas. En realidad es una gramática libre 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

Explicación:

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

Ejemplo:

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

Devuelve 1 si palíndromo, 0 si no.

Salida:

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

Explicación:

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