Creare un programma che converte la stringa di input in un palindromo a partire dalla stringa di input. Il programma stesso deve essere un palindromo.

Ad esempio input:, neverodstampa neveroddoreven. Dovresti gestire anche input multi-word, multi-line.

Dyalog APL, 6 4

⌽,,⌽

Provalo qui.

Altre soluzioni:

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

Spiegazione

Sono solo:

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

Monadico ,e ⊢non fa nulla sulle stringhe. Dyadic ,è concatenazione. Dyadic ⊢restituisce il suo operando destro. Ed ⌽è ovviamente un'inversione.

piet 19x2 = 38

Accetta input fino a quando non incontra 0x00. Non termina, ma l'output sarà corretto.

APL, 9

⍞←Z,⌽,Z←⍞

Spiegazione:

       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 byte

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

Provalo online qui

o..

GolfScript, 9 byte

.-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";

Provalo qui

C ++, 162 byte

#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 byte

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 byte

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

Questo deve essere eseguito con il Control.Applicativemodulo nell'ambito, che può essere impostato tramite il file ghci init .ghci: :m Control.Applicative(-> +22 byte).

Nessun trucco di commento, solo 7 funzioni in cui 4 di loro non vengono mai chiamati.

Se sono consentite funzioni (anziché programmi):

Haskell, 55 + 22 = 77 byte

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

Utilizzo f "qwer"->"qwerrewq"

Modifica: la versione precedente era semplicemente sbagliata.

Pyth, 11 byte

+z_z " z_z+

In Pyth, tutto ciò che precede con uno spazio non viene stampato. Quindi aggiungiamo semplicemente il negativo della stringa a se stesso, mettiamo uno spazio, iniziamo una stringa e rispecchiamo il lato sinistro della citazione "

Provalo online qui

Ruby, 44

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

Prende una stringa multilinea come input da stdin, genera una rappresentazione Ruby di quella stringa concatenata al suo contrario. Potrebbe tagliare un personaggio sostituendolo ||con #per commentare il codice morto sulla seconda riga.

Jolf, 9 byte

Lingua più recente, non competitiva

Prova qui

aη+i_i+ηa

Spiegazione: Ho appena iniziato Jolf e non credo di spiegarlo correttamente.

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$

Provalo online

Come suggerito da @mazzy, il codice può essere ridotto di 12 byte quando si utilizza un intervallo statico. Ciò, tuttavia, limita la lunghezza di input a 9 KB. Teoricamente sarebbero possibili 9 MB ma rallenterebbe significativamente il codice.

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

Fuzzy Octo Guacamole, 17 byte

_{La nebbia è più recente di questa sfida, quindi non è competitiva.}

^dz''sjX@Xjs''zd^

Alt soluzione in 19 byte:

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

Entrambi accettano input, duplicano e invertono e si uniscono alla pila.

Spiegazione:

^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

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

Il mio primo pensiero è stato Brainfuck, ma è impossibile abbinare le parentesi graffe ... per fortuna tinyBF ha un controllo del flusso più semplice.

Nessun commento, accetta una stringa terminata null come input e restituisce il risultato in una stringa terminata null. Puoi testarlo qui , basta essere avvisato che non si ferma (anche se Firefox richiede almeno di fermare lo script che non risponde).

ha commentato:

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

Nota che se lo codifichi in istruzioni a 2 bit, ridurrà la dimensione a 10 byte (non sarebbe un palindromo).

Python 3, 59 byte

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

Ho fatto del mio meglio per trovare una soluzione che utilizzava solo una riga ma non ho avuto fortuna.

Python 3, 79 byte

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

Il mio tentativo originale in cui ogni riga è un palindromo. Non penso che sia necessario per questa sfida, ma l'ho inclusa per ogni evenienza.

Vitsy, 9 byte

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

Provalo online!

Befunge , 37 byte

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

Provalo online!

La riga superiore spinge e stampa ogni carattere dell'input. La seconda riga (prima di @) stampa la pila al contrario, ma entriamo alla convenzionale _per consumare il -1 generato al termine della lettura dell'input. L'altra metà del codice (comprese quelle brutte nuove righe finali) rende la fonte un palindromo, ma i nevers corrono.

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

salvato 2 byte per l'uso di .Aggregate ()

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

Oh, il buon vecchio lambda, puoi prenderlo

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

e poi chiamalo con

f("neverod")

Perl, 45 byte

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

Abbastanza semplice, printè l'input ( $_=<>) seguito dal reversesuo. reverseritorna $_perché lo stiamo usando in un contesto scalare prefissando con ~~. Quindi abbiniamo ( m//usando ;come delimitatore), in un contesto vuoto, contro il contrario dello script.

Se possiamo garantire che non dovremo creare un palindromo di esrever,><=_$tnirpcui possiamo abbreviare il codice a 43 byte :

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

uso

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

Perl, 26 byte

Include 25 byte codice + 1 per -p.

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

Non penso che questo sia valido poiché richiede la -pbandiera che non credo possa essere facilmente combinata nei contenuti della sceneggiatura per creare un vero palindromo. Praticamente le stesse chiamate di cui sopra, tranne che si basa sul fatto che -paggiunge anche un ;dietro le quinte (su Perls più recenti ...) per chiudere m//.

uso

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

Pyth, 15

 k k+ z_z +k k 

Notare lo spazio all'inizio e alla fine.

Piuttosto fastidioso compito in Pyth. z_zstampa il palindromo desiderato, ma stampa z(la stringa di input) e _zl'inverso su due linee diverse. +combina le due parole, ma +alla fine richiede due nuove dichiarazioni alla fine (e all'inizio). Scelgo ke k, che sono solo stringhe vuote. Quindi molto spazio bianco, che sopprime la stampa (e la stampa di spazi vuoti, che generano naturalmente interruzioni di riga).

Poiché lo spazio bianco elimina ogni output tranne il +z_z, è possibile sostituire se kletterale con arity 0. Ad esempio 1 2+ z_z +2 1o T Z+ z_z +Z T.

Provalo online .

Javascript, 137 byte

Non sto usando il "trucco dei commenti" ma sto usando il trucco delle virgolette sfuggito 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 byte

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

PHP, 28 + 1 + 28 = 57 byte

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

accetta input dall'argomento della riga di comando. preventivo per più parole, sfuggire a nuove righe per più righe.

Python 2, 51 byte

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

Sono sorpreso che nessuno ci abbia pensato! Richiede input citato ( 'o "). Se le funzioni fossero state consentite, avrei potuto farlo invece per 37 byte:

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

C ++ 14, 152 116 byte

Come lambda senza nome, assume sdi esserestring

[](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(][

Vecchia soluzione:

[](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(][

Uso:

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 byte

«q«Â

Provalo online.

Spiegazione:

        # 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

O in alternativa:

R«q«R

Provalo online.

Dov'è il Rcontrario, e «prende di nuovo implicitamente l'input da concordare.

NOTA: se ci è consentito l'output neverodorevenper l'input neverod, che è ancora un palindromo, può essere fatto in 1 byte invece con il built-in palindromize:

û

Provalo online.

Assembly x86-64 (convenzione di chiamata x64 di Microsoft), 89 byte:

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

Disassembled:

 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

Si noti che il codice dopo l' retistruzione at 2Cnon è raggiungibile, quindi non importa che sia una sciocchezza

Japt , 4 byte

êêêê

Provalo online!

Come funziona

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

4 byte alternativi

pwwp

Provalo online!

Come funziona

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

Rovescio , 33 27 byte

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

Provalo online!

A differenza di molte soluzioni qui, questa in realtà non utilizzare il codice palindromised!

Spiegazione:

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.

Complessivamente, le istruzioni non eseguite sono:

       :   i  o :   |}0~Hi