Il y a eu plusieurs tentatives précédentes pour poser cette question, mais aucune n’est conforme aux normes modernes sur ce site. Par discussion sur Meta , je le republie de manière à permettre une concurrence loyale dans le cadre de nos règles modernes.

Contexte

Un palindrome est une chaîne qui "lit la même chose en avant et en arrière", c'est-à-dire que l'inverse de la chaîne est identique à la chaîne elle-même. Nous ne parlons pas de "palindromes commodes" ici, mais d'un renversement strict caractère par caractère; par exemple, ()()n'est pas un palindrome, mais l' ())(est.

La tâche

Ecrivez un programme ou une fonction prenant une chaîne S (ou l’équivalent approprié dans votre langue) en entrée et ayant une sortie Q (du type de votre choix). Vous pouvez utiliser tout moyen raisonnable pour saisir l’entrée et fournir la sortie.

• Lorsque l'entrée S est un palindrome, la sortie Q doit avoir une valeur A (identique pour tous les palindromes S ).
• Lorsque l'entrée S n'est pas un palindrome, la sortie Q doit avoir une valeur B (identique pour tout S non palindromique ).
• A et B doivent être distincts l'un de l'autre.

Ou en d'autres termes: mappez tous les palindromes sur une valeur et tous les non-palindromes sur une autre.

De plus, le programme ou la fonction que vous écrivez doit être un palindrome lui-même (c'est-à-dire que son code source doit être palindrome), ce qui en fait un défi à source restreinte .

Des clarifications

• Bien que trueet falsesoient des choix évidents pour A et B , vous pouvez utiliser deux valeurs distinctes pour vos sorties "is a palindrome" et "not a palindrome", qui ne doivent pas nécessairement être booléennes.
• Nous définissons l'inversion de chaîne au niveau du caractère ici; ééest palindromique, que le programme soit codé en UTF-8 ou en Latin-1, même s'il ne s'agit pas d'une séquence d'octets palindromique après le codage UTF-8.
• Cependant, même si votre programme contient des caractères non-ASCII, il ne doit fonctionner que pour une entrée ASCII. Spécifiquement, l’entrée S ne contiendra que des caractères ASCII imprimables (y compris l’espace, mais pas la nouvelle ligne). Cela signifie notamment que si vous traitez l'entrée comme une séquence d'octets plutôt qu'une séquence de caractères, votre programme sera toujours conforme à la spécification (sauf si le codage d'E / S de votre langue est très étrange). En tant que tel, la définition d'un palindrome dans la puce précédente importe uniquement lorsque vous vérifiez que le programme a une forme correcte.
• Cacher la moitié du programme dans un commentaire ou un littéral de chaîne, tout en étant peu créatif, est légal; vous êtes marqué sur la longueur, pas sur la créativité, alors n'hésitez pas à utiliser des méthodes «ennuyeuses» pour vous assurer que votre programme est un palindrome. Bien sûr, étant donné que votre score est long, certaines parties de votre programme qui ne font rien vont l’aggraver. Par conséquent, être capable d’utiliser les deux moitiés de votre programme sera probablement utile si vous pouvez le gérer. .
• Le critère de victoire étant mesuré en octets, vous devez spécifier le codage dans lequel votre programme est écrit pour pouvoir le marquer (bien que dans de nombreux cas, le codage que vous utilisez sera évident).

Critère de victoire

Même si le programme doit être un palindrome au niveau du personnage, nous utilisons des octets pour voir qui gagne. Plus précisément, plus votre programme est court, mesuré en octets, mieux c'est; c'est un défi de code-golf . Pour permettre la comparaison des soumissions (en particulier des soumissions dans la même langue), placez un nombre d'octets pour votre programme dans l'en-tête de votre soumission (plus un nombre de caractères, s'il diffère du nombre d'octets).

Brachylog (2), 3 octets dans la page de codes de Brachylog

I↔I

Essayez-le en ligne!

Il s'agit d'un programme complet qui prend une entrée via une entrée standard (en utilisant la syntaxe de Brachylog pour les constantes, c'est-à-dire que les chaînes sont entourées de guillemets), et une sortie via une sortie standard. Les sorties sont true.pour une entrée palindromique et false.pour une entrée non palindromique.

Non seulement ce programme est-il palindrome, mais il présente également une symétrie miroir gauche / droite (et probablement dans certaines polices haut / bas).

Explication

Dans Brachylog, les lettres majuscules marquent des points du programme qui ont des valeurs identiques; ceci est utilisé presque comme un circuit électrique pour transporter des informations d'une partie du programme à une autre. L'une des conséquences est que, si vous placez une commande entre une paire identique de lettres majuscules, vous affirmez en réalité que l'entrée et la sortie de la commande sont identiques. Brachylog prend implicitement une entrée, donc dans ce cas, nous affirmons également que l'entrée de la commande est la même que celle du programme. Dans ce programme, nous utilisons la commande ↔, qui inverse les choses (dans ce cas, les chaînes); de sorte que le programme affirme effectivement que l'entrée est la même en avant et en arrière.

Un programme complet (par opposition à une fonction) dans Brachylog renvoie un booléen, false.s'il n'existe aucun moyen de corriger toutes les assertions contenues dans le programme en même temps, ou true.si les assertions du programme sont toutes compatibles les unes avec les autres. Nous n’avons ici qu’une affirmation - inverser l’entrée ne la change pas - le programme agit donc comme un vérificateur de palindrome.

Pyth , 3 octets

_I_

Renvoie Vrai ou Faux .

Essayez-le en ligne!

Comment ça fonctionne

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

Python , 39 octets

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

Essayez-le en ligne!

C'est ennuyeux, mais s'il y a plus court en Python, ce sera impressionnant.

Gelée , 5 octets

ḂŒ
ŒḂ

Retourne 1 ou 0 . La première ligne est un lien d'assistance non exécuté, la deuxième ligne appelle le test du palindrome.

Essayez-le en ligne!

Gelée , 5 octets

⁼ṚaṚ⁼

Essayez-le en ligne!

Égale inverse et inverse égal.

Ou le plus efficace mais moins esthétique:

⁼Ṛ
Ṛ⁼

ou

Ṛ⁼
⁼Ṛ

Mathematica, 23 octets

QemordnilaP;PalindromeQ

Pas très intéressant, mais dans un souci de complétude ...

Ce qui précède est un CompoundExpressionqui évalue à PalindromeQ, un intégré qui résout le défi. QemordnilaPest simplement un identifiant indéfini, qui est ignoré à cause du ;.

Haskell, 87 85 44 34 octets

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

Explication: ((->) a)est une instance de Applicative (grâce @faubiguy), avec <*>défini comme

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

Donc, en substituant dans les arguments, on peut voir pourquoi cela fonctionne.

05AB1E , 3 octets

Code:

ÂQÂ

Explication:

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

Utilise le codage CP-1252 . Essayez-le en ligne!

PHP, 55 octets

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

De plus, le nom de la langue est un palindrome alors ... des points bonus!

MATL , 7 octets

tPX=XPt

Essayez-le en ligne!

Renvoie [1; 1] pour l'entrée palindromique et [0; 0] sinon.

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 octets

Maintenant, sans commentaire!

x:RVaQaVR:x

Prend l'entrée en tant qu'argument de ligne de commande; sorties 1pour palindrome, 0pour non-palindrome. Essayez-le en ligne!

Le noyau de ce que nous voulons faire est RVaQa: reverse(a) string-equals a. Le code x:RVaQacalcule ce résultat et l'assigne à x. VR:xAssigne ensuite la valeur de xà la variable VR. Comme cette affectation est la dernière instruction du programme, sa valeur est également imprimée automatiquement. Voila!

Pour une version intéressante précédente utilisant un comportement non défini, voir l'historique des révisions.

Perl 6 , 25 octets / caractères utf8

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

L'essayer

R, 111 103 octets

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

Pas la réponse la plus originale. #est le caractère de commentaire dans R

Ungolfed:

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

La chaîne de caractères de scanest convertie en octets bruts grâce à la charToRawfonction. Ces octets bruts sont comparés un par un à leurs équivalents à partir de la rev()fonction, ce qui inverse l'ordre de son argument. La sortie de cette partie est un vecteur de TRUEet / ou FALSE.
La allfonction affiche alors TRUEsi tous ces éléments sontTRUE

Ici, "\n"dans la scanfonction est nécessaire pour les entrées avec plus d'un mot.

Réponse précédente (en octets), 81 octets

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

avec - 24 octets grâce à @rturnbull .

RProgN , 11 octets

~]S.E E.S]~

La première moitié de ce travail fait le gros du travail, et par commodité de RProgN, la seconde moitié est 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.

Essayez-le en ligne!

Rétine , 53 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Essayez-le en ligne!

Je suis à peu près sûr que ce n'est pas encore optimal (la »ligne semble particulièrement inutile et j'ai une solution à 45 octets qui est palindromique à l'exception d'un caractère), mais je suppose que c'est un début.

GNU sed , 64 59 + 1 (indicateur r) = 60 octets UTF-8

Il m'a fallu un certain temps pour trouver une réponse sed qui n'utilise pas de section de commentaire pour transformer le code en palindrome. Au lieu de cela, j'utilise la ccommande qui imprimera la première moitié du code dans l'ordre inverse, seulement je m'assure que cette instruction n'est pas atteinte.

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

Le script s'imprime 1si la chaîne d'entrée n'est pas un palindrome (pensez-y comme une erreur). Si la chaîne est un palindrome, aucune sortie n'est donnée (pensez-y comme une sortie réussie).

Exécuter des exemples: ou essayez-le en ligne!

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

Explication:

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

/@.nzRoi\
\ioRzn.@/

Essayez-le en ligne!

Impressions Jabberwocky pour les palindromes et rien pour les non-palindromes. Fonctionne pour une entrée UTF-8 arbitraire.

Explication

S'agissant d'une tâche de traitement de chaîne, Alice devra opérer en mode ordinal pour la résoudre. Cela signifie à son tour que le pointeur d'instruction doit se déplacer en diagonale et que nous avons donc besoin d'au moins deux lignes pour que l'adresse IP puisse rebondir de haut en bas. Le saut de ligne dans un tel programme constitue un bon emplacement pour placer le personnage central du palindrome. Cela signifie que la deuxième ligne doit être l'inverse de la première. Mais comme nous n'exécutons que tous les autres caractères de chaque ligne, si nous nous assurons que la longueur de la ligne est impair, l'inverse du code s'intégrera parfaitement dans ses propres espaces. Le seul caractère qui n'est pas du tout utilisé est la barre oblique inversée, mais comme c'était arbitraire, je l'ai choisi pour que le programme soit beau et symétrique.

De toute façon, le code pertinent est le suivant:

/ . z o
 i R n @

Qui est exécuté en zigzag de gauche à droite.

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

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

Essayez-le en ligne! Appeler avec f "some string", retourne Trueou False.

L' =<<opérateur sur les fonctions fonctionne comme f=<<g = \s -> f (g s) ssi le code était équivalent f s=s==reverse s, ce qui, comme je viens de le remarquer, entraînerait le même nombre d'octets.

Version sans commentaire: (49 octets)

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

Essayez-le en ligne!

Appeler avec p "some string". Ceci sort Falsesi la chaîne donnée est un palindrome, et Truesi ce n'est pas un palindrome.

Explication:

J'ai trouvé ce commentaire gratuit sur palindrome en commençant par la version commentaire et en remplaçant le commentaire par une nouvelle ligne:

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

La deuxième ligne échoue car les parenthèses ne correspondent pas. Nous devons donc nous en débarrasser. Si nous avions une fonction equi vérifie l'égalité, alors

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

permettra à la fois compiler avec la deuxième ligne définissant un infix-opérateur <<=qui prend deux arguments esreveret eet renvoie la fonction p.

Pour définir ela fonction d’égalité, on écrit normalement e=(==)mais )==(=ene compile pas à nouveau. Au lieu de cela , nous pourrions explicitement prendre deux arguments et de les transmettre à ==: e x y=x==y. Maintenant, le code inversé est y==x=y x ecompilé mais redéfinit l' ==opérateur, ce qui entraîne l' e x y=x==yéchec de la définition . Cependant, si nous passons à l'opérateur d'inégalité /=, la définition inversée devient y=/x=y x eet définit un =/opérateur qui n'interfère pas avec l' /=opérateur d' origine .

OIL , 178 octets

Lit une entrée, l'explose, ajoute lentement sa longueur (en incrémentant et en décrémentant) à l'adresse à connaître après la chaîne, saute à une partie de code différente (au milieu), inverse le sens de la bande, implode la chaîne à nouveau, et vérifie si c'est la même chose que la chaîne d'origine. TL; DR: C'est pénible, comme d'habitude.

Sortie 40si la chaîne n'est pas un palindrome, 0si c'est le cas.

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 octets

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

Fonction d'appel favec chaîne

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

Japt , 7 2 octets

êê

Exécuter

Ancienne solution:

U¥UwU¥U

Essayez-le en ligne!

Explication

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'échappe pas aux fonctions sauf si une parenthèse fermante (ou un espace) est atteinte.

Cela peut être réécrit: U¥Uw(U¥U)→ U¥Uw→ U==Uw. Dans Japt, les parenthèses laissées au début et à la fin d'une fonction sont insérées automatiquement.

Utilitaires Bash + Unix, 49 octets

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

L'entrée est passée en argument.

La sortie est renvoyée dans le code de résultat - 0 pour un palindrome, 1 pour un non-palindrome.

Peut-être que quelqu'un peut faire mieux et ne pas simplement compter sur un commentaire pour rendre le code lui-même palindromique.

Essayez-le en ligne!

> <>, 11 octets

{=?!;
;!?={

Essayez-le ici!

Renvoie "\ nquelque chose sent le poisson ..." sur un palindrome valide, aucune sortie sur un palindrome invalide. Placez le palindrome sur la pile.

Java - 171 169 160 octets

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

Le commentaire à la fin est d'en faire un palindrome. Retourne P(alindrome)quand l'entrée est palindrome et N(ot)quand non.

Version non-golfée:

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 octets sauvegardés grâce à @DLosc

Merci à @Olivier Grégoire pour avoir signalé le nombre incorrect d'octets! Fixé maintenant

Java 8, 92 90 octets

Ceci est une version de commentaire. Si une chaîne contient son contraire, il s'agit d'un palindrome ( true), sinon ce n'est pas le cas ( false).

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

Essayez-le en ligne!

Mise à jour

• -2 [18-04-05] Basculé sur contient. Merci à Kevin Cruijssen !
• -2 [17-02-20] Removed ;« s
• -16 [17-02-22] Conversion automatique

En fait , 5 octets

;R=R;

Essayez-le en ligne!

La sortie vérité est [1]\n[1], et la sortie falsey est []\n[](dans les deux sorties, \nreprésente une nouvelle ligne littérale).

Explication:

;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 octets

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

Je dois dire que la déclaration inverse était coûteuse, mais je ne peux pas imaginer grand chose à faire pour changer cela. Être capable de couper les std:: symboles me sauverait environ 10 caractères, mais "en utilisant namespace std;" est un peu plus.

Je suppose que C ++ n'était pas vraiment destiné à la brièveté.

Prolog, 44 octets

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

Ceci utilise des grammaires à clauses définies. C'est en fait une grammaire sans contexte complet:

p -->
      []            % the empty string
   |                % or
      [_]           % a one character string
   |                % or
      [E],          % one character, followed by
      p,            % a palindrome, followed by
      [E].          % that same character

Usage:

?- phrase(p,"reliefpfeiler").
true 

?- phrase(p,"re").
false.

CJam, 13 octets

l_W%=e#e=%W_l

Explication:

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

Exemple:

> 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 octets, 15 caractères

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

Retourne 1 si palindrome, 0 sinon.

Sortie:

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

Explication:

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