Crie um programa que converta a sequência de entrada em um palíndromo começando com a sequência de entrada. O programa em si deve ser um palíndromo.

Por exemplo, entrada:, neverodimprima neveroddoreven. Você deve manipular entradas com várias palavras e várias linhas também.

Dyalog APL, 6 4

⌽,,⌽

Experimente aqui.

Outras soluções:

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

Explicação

Eles são apenas:

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

Monádico ,e ⊢não faz nada nas cordas. Diádico ,é concatenação. Diádico ⊢retorna seu operando direito. E ⌽é obviamente reversão.

piet 19x2 = 38

Aceita entrada até encontrar 0x00. Não termina, mas a saída estará correta.

APL, 9

⍞←Z,⌽,Z←⍞

Explicação:

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

Experimente online aqui

ou..

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

Experimente aqui

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

Isso deve ser executado com o Control.Applicativemódulo no escopo, que pode ser definido através do arquivo ghci init .ghci: :m Control.Applicative(-> +22 bytes).

Nenhum truque de comentário, apenas 7 funções em que 4 nunca são chamadas.

Se funções (em vez de programas) forem permitidas:

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"

Edit: a versão anterior estava errada.

Pitão, 11 bytes

+z_z " z_z+

No Pyth, qualquer coisa anterior a um espaço não é impressa. Então, simplesmente adicionamos o negativo da string a ela mesma, colocamos um espaço, iniciamos uma string e espelhamos o lado esquerdo da citação "

Experimente online aqui

Ruby, 44

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

Pega uma sequência multilinha como entrada de stdin, gera uma representação Ruby dessa sequência concatenada ao contrário. Pode aparar um caractere substituindo ||por #para comentar o código morto na segunda linha.

Jolf, 9 bytes

Idioma mais recente, não concorrente

Experimente aqui

aη+i_i+ηa

Explicação: Acabei de iniciar o Jolf e acho que não estou explicando isso corretamente.

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$

Experimente online

Conforme sugerido por @mazzy, o código pode ser reduzido em 12 bytes ao usar um intervalo estático. Isso, no entanto, limita o comprimento da entrada para 9KBytes. Teoricamente, seriam necessários 9 MBytes, mas isso diminuiria significativamente o código.

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

Fuzzy Octo Guacamole, 17 bytes

_{O FOG é mais novo que esse desafio, portanto não é competitivo.}

^dz''sjX@Xjs''zd^

Solução Alt em 19 bytes:

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

Ambos recebem entrada, duplicam e revertem e se juntam à pilha.

Explicação:

^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

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

Meu primeiro pensamento foi Brainfuck, mas é impossível combinar os aparelhos ... felizmente tinyBF tem um controle de fluxo mais simples.

Sem comentários, ele usa uma sequência terminada nula como entrada e retorna o resultado em uma sequência terminada nula. Você pode testá-lo aqui , esteja avisado de que ele não será interrompido (embora o Firefox ao menos peça para interromper o script que não 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.

Observe que se você o codificar em instruções de 2 bits, o tamanho será reduzido para 10 bytes (não seria um palíndromo).

Python 3, 59 bytes

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

Eu tentei o meu melhor para encontrar uma solução que usasse apenas uma linha, mas não tive sorte.

Python 3, 79 bytes

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

Minha tentativa original em que cada linha é um palíndromo. Não acho que seja necessário para esse desafio, mas o incluí apenas por precaução.

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

Experimente online!

Befunge , 37 bytes

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

Experimente online!

A linha superior empurra e imprime todos os caracteres da entrada. A segunda linha (antes da @) imprime a pilha no sentido inverso, mas entramos no contional _para consumir o -1 gerado ao concluir a leitura da entrada. A outra metade do código (incluindo as novas linhas feias) torna a fonte um palíndromo, mas a nevasca é executada.

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

salvou 2 bytes no uso de .Aggregate ()

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

Oh, o bom e velho lambda, você pode pegá-lo com

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

e depois chame-o com

f("neverod")

Perl, 45 bytes

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

Bem simples, printé a entrada ( $_=<>) seguida pela reverse. reverseretorna $_porque o estamos usando no contexto escalar prefixando com ~~. Em seguida, combinamos ( m//usando ;como delimitador), no contexto nulo, contra o reverso do script.

Se pudermos garantir, não precisaremos criar um palíndromo, esrever,><=_$tnirppois podemos reduzir o código para 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

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

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

Eu não acho que isso seja válido, pois requer a -pbandeira que eu acho que não pode ser facilmente combinada com o conteúdo do script para criar um verdadeiro palíndromo. Praticamente as mesmas chamadas acima, exceto que se baseia no fato de que -ptambém adiciona um ;segundo plano (nos Perls mais recentes ...) para fechar o m//.

Uso

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

Pitão, 15

 k k+ z_z +k k 

Observe o espaço no começo e no final.

Tarefa bastante chata em Pyth. z_zimprime o palíndromo desejado, mas imprime z(a sequência de entrada) e _zo inverso em duas linhas diferentes. +combina as duas palavras, mas +no final requer duas novas declarações no final (e no início). Eu escolho kek , que são apenas cadeias vazias. Em seguida, muito espaço em branco, que suprime a impressão (e a impressão de espaços vazios, que geram, naturalmente, quebras de linha).

Como o espaço em branco suprime todas as saídas, exceto a +z_z, você pode substituir ks e literal pela arity 0. Por exemplo, 1 2+ z_z +2 1ou T Z+ z_z +Z T.

Experimente online .

Javascript, 137 bytes

Eu não estou usando o "truque de comentário", mas estou usando o truque de aspas escapadas 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 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$(=?<

takes input from command line argument. quote for multi-word, escape newlines for multi-line.

Python 2, 51 bytes

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

I'm surprised no-one thought of this! Needs quoted input (' or "). If functions were allowed, I could have done this for 37 bytes instead:

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

C++14, 152 116 bytes

As unnamed lambda, assumes s to be string

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

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

«q«Â

Try it online.

Explanation:

        # 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

Or alternatively:

R«q«R

Try it online.

Where R is reverse, and the « takes the input implicitly again to concat with.

OBSERVAÇÃO: Se for permitido enviar neverodorevenpara a entrada neverod, que ainda é um palíndromo, isso pode ser feito em 1 byte, com o palindromize incorporado:

û

Experimente online.

Conjunto x86-64 (convenção de chamada Microsoft x64), 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

Observe que o código após a retinstrução at 2Cé inacessível, portanto não importa que seja um absurdo

Japonês , 4 bytes

êêêê

Experimente online!

Como 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

Experimente online!

Como 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

Backhand , 33 27 bytes

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

Experimente online!

Unlike a lot of the solutions here, this one actually does use the palindromised code!

Explanation:

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.

Altogether, the unexecuted instructions are:

       :   i  o :   |}0~Hi