入力文字列を入力文字列で始まる回文に変換するプログラムを作成します。プログラム自体は回文である必要があります。

たとえば、input：neverod、print neveroddoreven。複数ワード、複数行の入力も処理する必要があります。

Dyalog APL、6 4

⌽,,⌽

ここで試してみてください。

その他の解決策：

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

説明

彼らはただです：

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

モナド,と⊢文字列には何もしません。ダイアディック,は連結です。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.ApplicativeGHCiの初期化ファイルを介して設定することができる範囲内のモジュール、.ghci：:m Control.Applicative（ - > 22バイト）。

コメントトリックはありません。4つの関数が呼び出されない7つの関数のみです。

（プログラムではなく）関数が許可されている場合：

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では、スペースが先行するものはすべて印刷されません。そのため、文字列のネガを自分自身に追加し、スペースを入れ、文字列を開始して、引用の左側をミラーリングします」

こちらからオンラインでお試しください

ルビー、44

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

stdinからの入力として複数行の文字列を受け取り、その文字列のRuby表現をその逆に連結して出力​​します。置き換えることで文字をトリムでし||て#2行目デッドコードをコメントアウトします。

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バイト短縮できます。ただし、これは入力長を9Kバイトに制限します。理論的には9MBytesが可能ですが、コードが大幅に遅くなります。

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

ファジーオクトワカモレ、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.

tinyBF、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

1行だけを使用するソリューションを見つけるために最善を尽くしましたが、運がありませんでした。

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:~

オンラインでお試しください！

一番上の行は、入力のすべての文字をプッシュして印刷します。2番目の行（の前@）はスタックを逆に印刷しますが、_入力を読み終えたときに生成された-1を消費するために、contional に入ります。コードの残りの半分（これらの見苦しい末尾の改行を含む）は、ソースを回文にしますが、決して実行しません。

C＃（33 32 + 1）* 2 = 68 66バイト

.Aggregate（）の使用に2バイト節約

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

古き良きラムダ、あなたはそれをキャッチすることができます

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ものではないと思います。フラグが必要なため、スクリプトの内容に簡単に組み合わせて真の回文を作成できるとは思わないからです。上記とほぼ同じ呼び出しですが、を閉じるために（新しいPerlで）舞台裏を-p追加するという事実に依存して;いm//ます。

使用法

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

Pyth、15

 k k+ z_z +k k 

最初と最後のスペースに注意してください。

Pythでの非常に迷惑なタスク。z_z目的の回文を印刷しますが、2つの異なる行にz（入力文字列）と_z逆を印刷します。+は2つの単語を組み合わせますが+、最後に2つの新しいステートメントが最後（および最初）に必要です。とを選択kしkます。これらは空の文字列です。次に、印刷を抑制する大量の空白（および、もちろん改行を生成する空白を印刷）。

空白はを除くすべての出力を抑制+z_zするため、ksおよびリテラルをアリティ0に置き換えることができます。たとえば、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バイト

無名のラムダとして、想定している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入力用の出力が許可されている場合neverod、それはまだ回文であり、palindromizeビルトインを使用する代わりに1バイトで実行できます。

û

オンラインでお試しください。

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