Cree un programa que convierta la cadena de entrada en un palíndromo comenzando con la cadena de entrada. El programa en sí debe ser un palíndromo.

Por ejemplo, input:, neverodprint neveroddoreven. También debe manejar entradas de varias palabras y varias líneas.

Dyalog APL, 6 4

⌽,,⌽

Pruébalo aquí

Otras soluciones:

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

Explicación

Ellos son solo:

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

Monádico ,y ⊢no hace nada con cuerdas. Dyadic ,es concatenación. Dyadic ⊢devuelve su operando correcto. Y ⌽obviamente es reversión.

piet 19x2 = 38

Acepta entradas hasta que encuentre 0x00. No termina, pero la salida será correcta.

APL, 9

⍞←Z,⌽,Z←⍞

Explicación:

       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 bytes

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

Pruébalo en línea aquí

o..

GolfScript, 9 bytes

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

Pruébalo aquí

C ++, 162 bytes

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

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 bytes

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

Esto debe ejecutarse con el Control.Applicativemódulo en el alcance, que se puede configurar a través del archivo ghci init .ghci::m Control.Applicative (-> +22 bytes).

Sin truco de comentarios, solo 7 funciones donde 4 de ellas nunca se llaman.

Si se permiten funciones (en lugar de programas):

Haskell, 55 + 22 = 77 bytes

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

Uso f "qwer"->"qwerrewq"

Editar: la versión anterior era simplemente incorrecta.

Pyth, 11 bytes

+z_z " z_z+

En Pyth, todo lo que precede a un espacio no se imprime. Entonces simplemente agregamos el negativo de la cadena a sí mismo, ponemos un espacio, comenzamos una cadena y reflejamos el lado izquierdo de la cita "

Pruébalo en línea aquí

Rubí, 44

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

Toma una cadena multilínea como entrada de stdin, genera una representación Ruby de esa cadena concatenada en su reverso. Podría recortar un carácter reemplazándolo ||con #para comentar el código muerto en la segunda línea.

Jolf, 9 bytes

Lenguaje más nuevo, no competitivo

Intenta aquí

aη+i_i+ηa

Explicación: Acabo de comenzar Jolf y no creo que esté explicando esto correctamente.

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$

Pruébalo en línea

Como lo sugiere @mazzy, el código se puede acortar en 12 bytes cuando se usa un rango estático. Sin embargo, esto limita la longitud de entrada a 9 KB. Teóricamente, 9MBytes serían posibles, pero ralentizaría el código significativamente.

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

Fuzzy Octo Guacamole, 17 bytes

_{FOG es más nuevo que este desafío, por lo que no es competitivo.}

^dz''sjX@Xjs''zd^

Solución alternativa en 19 bytes:

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

Ambos toman entrada, duplican e invierten, y se unen a la pila.

Explicación:

^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

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

Mi primer pensamiento fue Brainfuck, pero es imposible hacer coincidir los frenos ... afortunadamente tinyBF tiene un control de flujo más simple.

No hay comentarios, toma una cadena terminada en nulo como entrada y devuelve el resultado en una cadena terminada en nulo. Puede probarlo aquí , solo tenga en cuenta que no se detiene (aunque Firefox al menos le pide que detenga el script que no responde).

Comentado:

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

Tenga en cuenta que si lo codifica en instrucciones de 2 bits, reduce el tamaño a 10 bytes (no sería un palíndromo).

Python 3, 59 bytes

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

Hice todo lo posible para encontrar una solución que solo usara una línea, pero no tuve suerte.

Python 3, 79 bytes

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

Mi intento original en el que cada línea es un palíndromo. No creo que sea necesario para este desafío, pero lo incluí por si acaso.

Vitsy, 9 bytes

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

Pruébalo en línea!

Befunge , 37 bytes

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

Pruébalo en línea!

La línea superior empuja e imprime cada carácter de entrada. La segunda línea (antes de @) imprime la pila en reversa, pero ingresamos en el contional _para consumir el -1 generado al terminar de leer la entrada. La otra mitad del código (incluidas las nuevas líneas feas) hace que la fuente sea un palíndromo, pero nunca se ejecuta.

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

guardado 2 bytes para el uso de .Aggregate ()

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

Oh, el buen viejo lambda, puedes atraparlo con

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

y luego llamarlo con

f("neverod")

Perl, 45 bytes

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

Bastante sencillo, printes la entrada ( $_=<>) seguida de la reversede ella. reversedevuelve $_porque lo estamos usando en contexto escalar con el prefijo ~~. Luego emparejamos ( m//usando; como delimitador), en contexto vacío, contra el reverso del guión.

Si podemos garantizar que no tendremos que crear un palíndromo esrever,><=_$tnirp, podemos acortar el código a 43 bytes :

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

Uso

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

Perl, 26 bytes

Incluye código de 25 bytes + 1 para -p.

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

No creo que esto sea válido ya que requiere la -pbandera que no creo que pueda combinarse fácilmente en el contenido del script para hacer un verdadero palíndromo. Casi las mismas llamadas que antes, excepto que se basa en el hecho de que -ptambién agrega un; detrás de escena (en Perls más nuevos ...) para cerrar el m//.

Uso

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

Pyth, 15

 k k+ z_z +k k 

Observe el espacio al principio y al final.

Tarea bastante molesta en Pyth. z_zimprime el palíndromo deseado, pero imprime z(la cadena de entrada) y _zel inverso en dos líneas diferentes. +combina las dos palabras, pero +al final requiere dos nuevas declaraciones al final (y al principio). Yo elijo kyk , que son solo cadenas vacías. Luego, mucho espacio en blanco, que suprime la impresión (y la impresión de espacios vacíos, que generan, por supuesto, saltos de línea).

Dado que el espacio en blanco suprime todas las salidas, excepto la +z_z, puede reemplazar el ksy literal con arity 0. Eg 1 2+ z_z +2 1oT Z+ z_z +Z T .

Pruébalo en línea .

Javascript, 137 bytes

No estoy usando el "truco de comentarios" pero estoy usando el truco de comillas escapado jajaja.

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

JavaScript, 58 bytes

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

PHP, 28 + 1 + 28 = 57 bytes

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

toma datos del argumento de la línea de comando. Presupuesto para palabras múltiples, escape de líneas nuevas para líneas múltiples.

Python 2, 51 bytes

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

¡Me sorprende que nadie haya pensado en esto! Necesita entrada citada ( 'o "). Si se permitieran las funciones, podría haber hecho esto por 37 bytes:

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

C ++ 14, 152116 bytes

Como lambda sin nombre, se supone sque esstring

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

Vieja solución:

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

«q«Â

Pruébalo en línea.

Explicación:

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

R«q«R

Pruébalo en línea.

Donde Res inverso, y «toma la entrada implícitamente de nuevo para concat.

NOTA: Si se nos permite emitir neverodorevenpara la entrada neverod, que sigue siendo un palíndromo, se puede hacer en 1 byte con el palindromizado incorporado:

û

Pruébalo en línea.

Asamblea x86-64 (convención de llamadas x64 de Microsoft), 89 bytes:

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

Desmontado:

 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

Tenga en cuenta que el código después de la retinstrucción en 2Ces inalcanzable, por lo que no importa que no tenga sentido

Japt , 4 bytes

êêêê

Pruébalo en línea!

Cómo funciona

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

Alternativa 4 bytes

pwwp

Pruébalo en línea!

Cómo funciona

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

Revés , 33 27 bytes

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

Pruébalo en línea!

A diferencia de muchas de las soluciones aquí, esta en realidad funciona utilizar el código palindromised!

Explicación:

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.

En total, las instrucciones no ejecutadas son:

       :   i  o :   |}0~Hi