Créez un programme qui convertit la chaîne d'entrée en un palindrome commençant par la chaîne d'entrée. Le programme lui-même doit être un palindrome.

Par exemple, saisissez neverod:, imprimez neveroddoreven. Vous devez également gérer les entrées multi-mots et multi-lignes.

Dyalog APL, 6 4

⌽,,⌽

Essayez-le ici.

Autres solutions:

⌽,⊢⊢,⌽
⌽⊢⊢,⊢⊢⌽

Explication

Ce ne sont que:

{⌽((,⍵),(⌽⍵))}
{⌽((,⍵)⊢((⊢⍵),(⌽⍵)))}
{(⌽⍵)⊢((⊢⍵),((⊢⍵)⊢(⌽⍵)))}

Monadic ,et ⊢ne fait rien sur les cordes. Dyadique ,est concaténation. Dyadic ⊢retourne son opérande droit. Et ⌽c'est évidemment la réversion.

piet 19x2 = 38

Accepte l'entrée jusqu'à ce qu'elle rencontre 0x00. Ne se termine pas, mais la sortie sera correcte.

APL, 9

⍞←Z,⌽,Z←⍞

Explication:

       Z←⍞  ⍝ read a line from the keyboard, and store it in Z
      ,     ⍝ flatten into one-dimensional array (this has no effect here)
     ⌽      ⍝ reverse
   Z,       ⍝ concatenate Z to its reverse
⍞←         ⍝ explicit output (not necessary, but it makes it a palindrome)

CJam, 13 octets

qL;_-1%1-_;Lq

qL;                 "Read the input, Put an empty array on stack and pop that array";
   _-1%             "Now the string is on top, make a copy and reverse the copy";
       1-           "Remove occurrences of integer 1 from the reverse string. [no-op]";
         _;         "Copy the reversed string and pop it";
           Lq       "Put an empty array on stack and read the remaining input. Remaining";
                    "input will be empty as we already read whole of the input";

Essayez-le en ligne ici

ou..

GolfScript, 9 octets

.-1%}%1-.

.                 "Input is already on stack. Make a copy";
 -1%              "Reverse the copy";
    }             "This marks the beginning of a super comment. Anything after this in the";
                  "code is a comment";
     %1-.         "no-op comment";

Essayez-le ici

C ++, 162 octets

#include<cstdio>//
main(){int c=getchar();if(c>0)putchar(c),main(),putchar(c);}//};)c(rahctup,)(niam,)c(rahctup)0>c(fi;)(rahcteg=c tni{)(niam
//>oidtsc<edulcni#

C, 117 octets

main(c){c=getchar();if(c>0)putchar(c),main(),putchar(c);}//};)c(rahctup,)(niam,)c(rahctup)0>c(fi;)(rahcteg=c{)c(niam

Haskell, 102 + 22 = 124 octets

a b fa=fa<|>b
fa=reverse>>=a
main=interact fa
niam=main
af tcaretni=niam
a=>>esrever=af
b>|<af=af b a

Cela doit être exécuté avec le Control.Applicativemodule dans la portée, qui peut être défini via le fichier d'initialisation ghci.ghci : :m Control.Applicative(-> +22 octets).

Pas de truc de commentaire, juste 7 fonctions dont 4 ne sont jamais appelées.

Si des fonctions (au lieu de programmes) sont autorisées:

Haskell, 55 + 22 = 77 octets

a b fa=fa<|>b
f=reverse>>=a
a=>>esrever=f
b>|<af=af b a

Utilisation f "qwer"->"qwerrewq"

Edit: la version précédente était juste fausse.

Pyth, 11 octets

+z_z " z_z+

En Pyth, tout ce qui précède avec un espace n'est pas imprimé. Donc, nous ajoutons simplement le négatif de la chaîne à lui-même, mettons un espace, commençons une chaîne et reflétons le côté gauche de la citation "

Essayez-le en ligne ici

Rubis, 44

s=gets p
s+=s.reverse||esrever.s=+s
p steg=s

Prend une chaîne multiligne en entrée de stdin, génère une représentation Ruby de cette chaîne concaténée à son inverse. Pourrait couper un caractère en le remplaçant ||par #pour mettre en commentaire le code mort sur la deuxième ligne.

Jolf, 9 octets

Langue plus récente, non concurrente

Essayez ici

aη+i_i+ηa

Explication: je viens de commencer Jolf et je ne pense pas que j'explique cela correctement.

aη         alert function, arity of the function can't be reduced by 1 so it stays at 1
  +i_i     concatenate the input with the reversed input
      +η   arity of the add reduced by 1, it just takes the following character (a)
        a  returns the input

PowerShell, 67

$args|%{$_+-join$_[$_.Length..0]}#}]0..htgneL._$[_$nioj-+_${%|sgra$

Essayez-le en ligne

Comme suggéré par @mazzy, le code peut être raccourci de 12 octets lors de l'utilisation d'une plage statique. Cependant, cela limite la longueur d'entrée à 9 Ko. Théoriquement, 9 Mo seraient possibles, mais cela ralentirait considérablement le code.

$args|%{$_+-join$_[9kb..0]}#}]0..bk9[_$nioj-+_${%|sgra$

Octo Guacamole flou, 17 octets

_{Le brouillard est plus récent que ce défi, il ne s'agit donc pas d'une compétition.}

^dz''sjX@Xjs''zd^

Solution alternative en 19 octets:

^Czs''.jX@Xj.''szC^

Ils prennent tous deux en entrée, dupliquent et inversent, et rejoignent la pile.

Explication:

^dz''sj@js''zd^
^                # Get input
 d               # Duplicate ToS (input)
  z              # Reverse ToS
   ''            # Push empty string (for joining separator)
     s           # Move the empty string to the inactive stack
      j          # Join the active stack with the top of the inactive stack as the delimiter and push the result.
       X         # Print the ToS
        @        # End the program
        Xjs''zd^  # Backwards version of the beginning.

tinyBF , 40

|=||==>|=|=|=+|=>==||==>=|+=|=|=|>==||=|

Ma première pensée a été Brainfuck, mais il est impossible de faire correspondre les accolades ... heureusement, tinyBF a un contrôle de flux plus simple.

Aucun commentaire, il prend en entrée une chaîne terminée par null et renvoie le résultat dans une chaîne terminée par null. Vous pouvez le tester ici , sachez simplement qu'il ne s'arrête pas (bien que Firefox invite au moins à arrêter le script qui ne répond pas).

Commenté:

|=|                        Retrieve a byte of input.
|                          Positive (opening) bracket.
   ==                      Output the byte.
   >                       Move the pointer in positive direction.
   |=|                     Retrieve a byte of input.
   =                       Switch direction to negative.
|                          Negative (closing) bracket.
=                          Switch direction.
+                          Increment byte to execute return loop.
|                          Opening bracket.
   =>                      Move the pointer in negative direction.
   ==                      Output the byte.
|                          Closing bracket.
|=|                        Output the null terminator.
|==>|=|=|=+|=>==|          ...and keep null terminating it just to be sure.

Notez que si vous le codez en instructions 2 bits, il réduit la taille à 10 octets (ce ne serait pas un palindrome).

Python 3, 59 octets

a=input()#
print(a+a[::-1])#([1-::]a+a)tnirp
#()tupni=a

J'ai fait de mon mieux pour trouver une solution qui n'utilisait qu'une seule ligne mais je n'ai pas eu de chance.

Python 3, 79 octets

a=input()#()tupni=a#
print(a+a[::-1])#([1-::]a+a)tnirp
#a=input()#()tupni=a

Ma tentative originale dans laquelle chaque ligne est un palindrome. Je ne pense pas que ce soit nécessaire pour ce défi, mais je l'ai inclus juste au cas où.

Vitsy, 9 octets

z:Zr?rZ:z
z          Grab all string input from the command line arguments.
 :         Duplicate this stack.
  Z        Print all elements in this stack as a string.
   r       Reverse (reverses an empty stack).
    ?      Go right a stack.
     r     Reverse (reverses the input).
      Z    Print all elements in this stack as a string.
       :   Duplicate the stack (duplicates an empty stack).
        z  Grab all input from the command line (the command line arguments stack is already empty).

Essayez-le en ligne!

Befunge , 37 octets

~:0`!#v_:,
  >:#,_@_,#:>  
,:_v#!`0:~

Essayez-le en ligne!

La ligne supérieure pousse et imprime chaque caractère d'entrée. La deuxième ligne (avant le @) imprime la pile en sens inverse, mais nous entrons au contional _pour consommer le -1 généré à la fin de la lecture de l'entrée. L'autre moitié du code (y compris ces tristes nouvelles lignes laides) fait de la source un palindrome, mais ne fonctionne jamais.

C # ( 33 32 + 1) * 2 = 68 66 octets

enregistré 2 octets à l'utilisation de .Aggregate ()

s=>s+s.Aggregate("",(a,b)=>b+a);//;)a+b>=)b,a(,""(etagerggA.s+s>=s

Oh le bon vieux lambda, tu peux l'attraper avec

Func<string, string> f=<lambda here>

puis appelez-le avec

f("neverod")

Perl, 45 octets

;print$_=<>,~~reverse;m;esrever~~,><=_$tnirp;

Assez simple, c'est printl'entrée ( $_=<>) suivie de celle reverse-ci. reverserenvoie $_parce que nous l'utilisons dans un contexte scalaire en préfixant avec ~~. Ensuite, nous comparons (en m//utilisant ;comme délimiteur), dans un contexte vide, contre l'inverse du script.

Si nous pouvons garantir nous n'aurons pas à créer un palindrome de esrever,><=_$tnirpnous pouvons raccourcir le code à 43 octets :

g.print$_=<>,reverse.m.esrever,><=_$tnirp.g

Usage

echo -n 'neverod' | perl -e 'g.print$_=<>,reverse.m.esrever,><=_$tnirp.g'
neveroddoreven

Perl, 26 octets

Comprend un code de 25 octets + 1 pour -p.

$_.=reverse;m;esrever=._$

Je ne pense pas que cela soit valide car il nécessite le -pdrapeau qui, je pense, ne peut pas être facilement combiné dans le contenu du script pour faire un vrai palindrome. À peu près les mêmes appels que ci-dessus, sauf qu'il repose sur le fait qu'il -pajoute également un ;arrière-plan (sur les Perls plus récents ...) pour fermer le m//.

Usage

echo -n 'neverod' | perl -pe ';$_.=reverse;m;esrever=._$;'
neveroddoreven

Pyth, 15

 k k+ z_z +k k 

Remarquez l'espace au début et à la fin.

Tâche assez ennuyeuse en Pyth. z_zimprime le palindrome souhaité, mais il imprime z(la chaîne d'entrée) et _zl'inverse sur deux lignes différentes. +combine les deux mots, mais +à la fin nécessite deux nouvelles déclarations à la fin (et au début). Je choisis ketk , qui ne sont que des chaînes vides. Ensuite, beaucoup d'espace blanc, ce qui supprime l'impression (et l'impression d'espaces vides, qui génèrent bien sûr des sauts de ligne).

Étant donné que l'espace blanc supprime toutes les sorties à l'exception de la +z_z, vous pouvez remplacer le ks et le littéral par l'arité 0. Par exemple, 1 2+ z_z +2 1ou T Z+ z_z +Z T.

Essayez-le en ligne .

Javascript, 137 octets

Je n'utilise pas la "astuce de commentaire" mais j'utilise l'astuce de guillemets échappés lol.

"a\"};))''(nioj.)(esrever.)''(tilps.b(tacnoc.b nruter{)b(a noitcnuf";function a(b){return b.concat(b.split('').reverse().join(''));};"\a"

JavaScript, 58 octets

p=>p+[...p].reverse().join``//``nioj.)(esrever.]p...[+p>=p

PHP, 28 + 1 + 28 = 57 octets

<?=($x=$argv[1]).strrev($x);#;)x$(verrts.)]1[vgra$=x$(=?<

prend l'entrée de l'argument de ligne de commande. devis pour plusieurs mots, échapper aux nouvelles lignes pour plusieurs lignes.

Python 2, 51 octets

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

Je suis surpris que personne n'y ait pensé! Nécessite une entrée citée ( 'ou "). Si les fonctions avaient été autorisées, j'aurais pu le faire pour 37 octets à la place:

lambda x:x+x[::-1]#]1-::[x+x:x adbmal

C ++ 14, 152 116 octets

En tant que lambda sans nom, suppose sêtrestring

[](auto s){decltype(s)r;for(auto c:s){r=c+r;}return s+r;}//};r+s nruter};r+c=r{)s:c otua(rof;r)s(epytlced{)s otua(][

Ancienne solution:

[](auto s){auto r=s;for(auto p=s.rbegin()-1;++p!=s.rend();r+=*p);return r;}//};r nruter;)p*=+r;)(dner.s=!p++;1-)(nigebr.s=p otua(rof;s=r otua{)s otua(][

Usage:

auto f=[](auto s){decltype(s)r;for(auto c:s){r=c+r;}return s+r;};

main(){
 string a="123456789";
 cout << f(a) << endl;
}

05AB1E , 5 octets

«q«Â

Essayez-le en ligne.

Explication:

        # Bifurcate (short for Duplicate & Reverse) the (implicit) input
         #  i.e. "neverod" → "neverod" and "doreven"
 «       # Concat both together
         #  i.e. "neverod" and "doreven" → "neveroddoreven"
  q      # Exit the program (and implicitly output the concatted result)
   «Â    # No-ops

Ou bien:

R«q«R

Essayez-le en ligne.

Où Rest inversé, et «prend à nouveau implicitement l'entrée pour concaténer.

REMARQUE: Si nous sommes autorisés à sortir neverodorevenpour l'entrée neverod, qui est toujours un palindrome, cela peut être fait en 1 octet à la place avec le palindromize intégré:

û

Essayez-le en ligne.

Assemblage x86-64 (convention d'appel Microsoft x64), 89 octets:

80 39 00 48 8B D1 4C 8B C1 74 0B 48 FF C2 49 FF C0 80 3A 00 75 F5 48 FF CA 8A 02 41 88 00 48 8B C2 48 FF CA 49 FF C0 48 3B C1 77 ED C3 ED 77 C1 3B 48 C0 FF 49 CA FF 48 C2 8B 48 00 88 41 02 8A CA FF 48 F5 75 00 3A 80 C0 FF 49 C2 FF 48 0B 74 C1 8B 4C D1 8B 48 00 39 80

Démonté:

 0000000000000000: 80 39 00           cmp         byte ptr [rcx],0
 0000000000000003: 48 8B D1           mov         rdx,rcx
 0000000000000006: 4C 8B C1           mov         r8,rcx
 0000000000000009: 74 0B              je          0000000000000016
 000000000000000B: 48 FF C2           inc         rdx
 000000000000000E: 49 FF C0           inc         r8
 0000000000000011: 80 3A 00           cmp         byte ptr [rdx],0
 0000000000000014: 75 F5              jne         000000000000000B
 0000000000000016: 48 FF CA           dec         rdx
 0000000000000019: 8A 02              mov         al,byte ptr [rdx]
 000000000000001B: 41 88 00           mov         byte ptr [r8],al
 000000000000001E: 48 8B C2           mov         rax,rdx
 0000000000000021: 48 FF CA           dec         rdx
 0000000000000024: 49 FF C0           inc         r8
 0000000000000027: 48 3B C1           cmp         rax,rcx
 000000000000002A: 77 ED              ja          0000000000000019
 000000000000002C: C3                 ret
 000000000000002D: ED                 in          eax,dx
 000000000000002E: 77 C1              ja          FFFFFFFFFFFFFFF1
 0000000000000030: 3B 48 C0           cmp         ecx,dword ptr [rax-40h]
 0000000000000033: FF 49 CA           dec         dword ptr [rcx-36h]
 0000000000000036: FF 48 C2           dec         dword ptr [rax-3Eh]
 0000000000000039: 8B 48 00           mov         ecx,dword ptr [rax]
 000000000000003C: 88 41 02           mov         byte ptr [rcx+2],al
 000000000000003F: 8A CA              mov         cl,dl
 0000000000000041: FF 48 F5           dec         dword ptr [rax-0Bh]
 0000000000000044: 75 00              jne         0000000000000046
 0000000000000046: 3A 80 C0 FF 49 C2  cmp         al,byte ptr [rax+FFFFFFFFC249FFC0h]
 000000000000004C: FF 48 0B           dec         dword ptr [rax+0Bh]
 000000000000004F: 74 C1              je          0000000000000012
 0000000000000051: 8B 4C D1 8B        mov         ecx,dword ptr [rcx+rdx*8-75h]
 0000000000000055: 48 00 39           add         byte ptr [rcx],dil
 0000000000000058: 80

Notez que le code après l' retinstruction à 2Cest inaccessible, donc peu importe que ce soit un non-sens

Japt , 4 octets

êêêê

Essayez-le en ligne!

Comment ça marche

U.ê("ê".ê("ê"))  Transpiled to JS

       .ê("ê")   String.ê(string): true if `this` is palindrome
    "ê".ê("ê")   true (treated same as 1)
U.ê(          )  String.ê(number): palindromify
                   "abc"->"abccba" if `number` is odd, "abcba" otherwise
                 `true` is odd number, so we achieve the desired function

Alternative 4 octets

pwwp

Essayez-le en ligne!

Comment ça marche

U.p("w".w("p"))  Transpiled to JS
    "w".w(   )   Reverse of "w" ("p" is ignored)
U.p("w")         Append U.w(), which is reverse of U, to the right of U

Revers , 33 27 octets

iH~0}|{<:: oi]io ::<{|}0~Hi

Essayez-le en ligne!

Contrairement à beaucoup de solutions ici, celle-ci fait ne n'utiliser le code palindromised!

Explication:

i  0 |{      Get the first character and enter the loop
        :  o    Output the character while preserving it
              i  :     Get input and duplicate it
                   <{  Turn around
             ]         Increment the copy to check if EOF   
    }| <    Loop again if not EOF
  ~   If EOF, pop the extra copy of EOF
 H    Terminate, printing the contents of the stack.

Au total, les instructions non exécutées sont:

       :   i  o :   |}0~Hi