创建一个程序，将输入字符串转换为以输入字符串开头的回文。该程序本身必须是回文。

例如输入：neverod，打印neveroddoreven。您还应该处理多字，多行输入。

Dyalog APL，6 4

⌽,,⌽

在这里尝试。

其他解决方案：

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

说明

它们只是：

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

单声道,，⊢对字符串不执行任何操作。Dyadic ,是串联的。Dyadic ⊢返回其右操作数。并且⌽显然是还原。

Piet 19x2 = 38

接受输入，直到遇到0x00。不会终止，但是输出将是正确的。

APL，9

⍞←Z,⌽,Z←⍞

说明：

       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个字节

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

在这里在线尝试

要么..

GolfScript，9个字节

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

在这里尝试

C ++，162个字节

#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字节

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字节

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

这必须Control.Applicative在范围内的模块下运行，可以通过ghci init文件进行设置.ghci：:m Control.Applicative（-> +22字节）。

没有注释技巧，只有7个函数从未调用其中的4个。

如果允许使用功能（而不是程序）：

Haskell，55 + 22 = 77字节

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

用法f "qwer"->"qwerrewq"

编辑：以前的版本是错误的。

Pyth，11个字节

+z_z " z_z+

在Pyth中，不打印任何以空格开头的内容。因此，我们只需将字符串的负数添加到自身中，放置一个空格，启动一个字符串，然后在报价单的左侧进行镜像”

在这里在线尝试

Ruby，44岁

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

从stdin接受多行字符串作为输入，输出该字符串的Ruby表示，并串接成反向。可以通过替换||为#来修剪字符，以注释掉第二行中的无效代码。

Jolf，9个字节

较新的语言，没有竞争

在这里尝试

aη+i_i+ηa

说明：我只是刚开始做Jolf，我认为我没有正确解释这一点。

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$

在线尝试

如@mazzy所建议，使用静态范围时，代码可以缩短12个字节。但是，这将输入长度限制为9KB。从理论上讲9MBytes是可能的，但是它将大大降低代码的速度。

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

Fuzzy Octo鳄梨调味酱，17个字节

_{FOG比此挑战要新，因此这是不竞争的。}

^dz''sjX@Xjs''zd^

19个字节的替代解决方案：

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

它们都接受输入，重复和反向，然后加入堆栈。

说明：

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

微小BF 40

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

我的第一个念头是Brainfuck，但无法匹配花括号...幸运的是tinyBF具有更简单的流控制。

没有注释，它将以零终止的字符串作为输入，并以零终止的字符串返回结果。您可以在此处对其进行测试，只是要警告它不会停止（尽管Firefox至少会提示您停止无响应的脚本）。

评论：

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

请注意，如果将其编码为2位指令，则会将其大小缩减为10个字节（不会是回文）。

Python 3，59个字节

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

我尽力找到一个只用一行的解决方案，但是我没有运气。

Python 3，79个字节

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

我最初的尝试是每行都是回文。我认为这个挑战不是必需的，但我以防万一。

Vitsy，9个字节

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

在线尝试！

Befunge，37个字节

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

在线尝试！

第一行推入并打印输入的每个字符。第二行（在之前@）以相反的方式打印堆栈，但是我们按惯例输入_以消耗完成读取输入时生成的-1。代码的另一半（包括那些难看的尾随换行符）使源成为回文，但永不运行。

C＃（33 32 +1）* 2 = 68 66字节

保存了2个字节以使用.Aggregate（）

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

哦，好老的lambda，你可以抓住它

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

然后用

f("neverod")

Perl，45个字节

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

非常简单，print输入（$_=<>）后跟reverse。之所以reverse返回，$_是因为我们在标量上下文中使用前缀~~。然后，我们匹配（m//使用;作为分隔符），在无效的情况下，对脚本的反向。

如果可以保证，我们将不必创建回文，esrever,><=_$tnirp我们可以将代码缩短为43个字节：

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

用法

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

Perl，26个字节

包含25个字节的代码+ 1个-p。

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

我认为这是不正确的，因为它需要-p我不认为可以轻易将其组合到脚本内容中以构成真正回文的标志。与上面几乎相同的调用，不同之处在于它依赖于以下事实：在幕后（在更新的Perls上）-p添加了一个;闭包m//。

用法

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

珀斯，15岁

 k k+ z_z +k k 

注意开头和结尾的空格。

在Pyth中，这很烦人。z_z打印所需的回文，但在两个不同的行上打印z（输入字符串）和_z逆。+合并了两个单词，但+最后在末尾（和开头）需要两个新语句。我选择k和k，它们只是空字符串。然后出现大量空白，这会抑制打印（以及打印空白空间，这当然会产生换行符）。

由于空格会抑制除之外的所有输出+z_z，因此您可以将ks和文字替换为arity0 。例如，1 2+ z_z +2 1或T Z+ z_z +Z T。

在线尝试。

Javascript，137个字节

我不是在使用“注释技巧”，而是在使用转义引号技巧。

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

JavaScript，58个字节

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

PHP，28 + 1 + 28 = 57字节

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

从命令行参数获取输入。多字报价，多行转义。

Python 2，51字节

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

我很惊讶没有人想到这一点！需要带引号的输入（'或"）。如果允许使用函数，则可以用37个字节来代替：

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

C ++ 14、152 116字节

作为未命名的lambda，假定s为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(][

旧解决方案：

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

用法：

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 个字节

«q«Â

在线尝试。

说明：

        # 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

或者：

R«q«R

在线尝试。

where R是反向的，并且«再次隐式地接受输入。

注意：如果允许我们neverodoreven为input 输出neverod仍然是回文的输入，则可以用1个字节来完成，而不用内置的palindromize：

û

在线尝试。

x86-64程序集（Microsoft x64调用约定），89字节：

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

拆解：

 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

请注意，ret指令后面的代码2C是无法访问的，因此不要说废话

Japt，4个字节

êêêê

在线尝试！

怎么运行的

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个字节

pwwp

在线尝试！

怎么运行的

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

反手，33 27字节

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

在线尝试！

与这里的许多解决方案不同，该解决方案实际上可以使用palindromised代码！

说明：

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.

总共，未执行的指令是：

       :   i  o :   |}0~Hi