Buat program, yang mengubah string input menjadi palindrome dimulai dengan string input. Program itu sendiri harus berupa palindrome.

Misalnya input neverod:, cetak neveroddoreven. Anda juga harus menangani input multi-kata, multi-jalur.

Dyalog APL, 6 4

⌽,,⌽

Coba di sini.

Solusi lain:

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

Penjelasan

Mereka hanya:

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

Monadik ,dan ⊢tidak melakukan apa pun pada string. Diad ,adalah penggabungan. Dyadic ⊢mengembalikan operan kanannya. Dan ⌽jelas merupakan pembalikan.

piet 19x2 = 38

Menerima input hingga bertemu 0x00. Tidak berhenti, tetapi output akan benar.

APL, 9

⍞←Z,⌽,Z←⍞

Penjelasan:

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

Cobalah online di sini

atau..

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

Coba di sini

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

Ini harus dijalankan dengan Control.Applicativemodule in scope, yang dapat diatur melalui file ghci init .ghci: :m Control.Applicative(-> +22 bytes).

Tidak ada trik komentar, hanya 7 fungsi di mana 4 dari mereka tidak pernah dipanggil.

Jika fungsi (bukan program) diizinkan:

Haskell, 55 + 22 = 77 byte

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

Penggunaan f "qwer"->"qwerrewq"

Sunting: versi sebelumnya salah.

Pyth, 11 byte

+z_z " z_z+

Dalam Pyth, apa pun yang diawali dengan spasi tidak dicetak. Jadi kita cukup menambahkan negatif dari string ke dirinya sendiri, memberi spasi, memulai string dan mencerminkan sisi kiri dari kutipan "

Cobalah online di sini

Ruby, 44

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

Mengambil string multiline sebagai input dari stdin, menampilkan representasi Ruby dari string yang disatukan dengan kebalikannya. Dapat memangkas karakter dengan mengganti ||dengan #mengomentari kode mati di baris kedua.

Jolf, 9 byte

Bahasa yang lebih baru, tidak bersaing

Coba Di Sini

aη+i_i+ηa

Penjelasan: Saya baru saja memulai Jolf dan saya tidak berpikir saya menjelaskan ini dengan benar.

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$

Cobalah online

Seperti yang disarankan oleh @mazzy kode dapat disingkat 12 byte saat menggunakan rentang statis. Ini, bagaimanapun, membatasi panjang input ke 9KBytes. Secara teori 9MBytes akan mungkin tetapi akan memperlambat kode secara signifikan.

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

Fuzzy Octo Guacamole, 17 byte

_{FOG lebih baru dari tantangan ini, jadi ini tidak bersaing.}

^dz''sjX@Xjs''zd^

Solusi alternatif dalam 19 byte:

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

Mereka berdua mengambil input, menggandakan dan membalikkan, dan bergabung dengan tumpukan.

Penjelasan:

^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

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

Pikiran pertama saya adalah Brainfuck, tetapi tidak mungkin untuk mencocokkan kawat gigi ... untungnya BB kecil memiliki kontrol aliran yang lebih sederhana.

Tidak ada komentar, dibutuhkan string yang diakhiri nol sebagai input dan mengembalikan hasilnya dalam string yang diakhiri nol. Anda dapat mengujinya di sini , hanya diperingatkan dulu bahwa itu tidak berhenti (walaupun Firefox setidaknya meminta untuk menghentikan skrip yang tidak merespons).

Berkomentar:

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

Perhatikan bahwa jika Anda menyandikannya ke dalam instruksi 2 bit, ia memotong ukurannya menjadi 10 byte (tidak akan menjadi palindrom).

Python 3, 59 byte

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

Saya mencoba yang terbaik untuk menemukan solusi yang hanya menggunakan satu baris tetapi saya tidak beruntung.

Python 3, 79 byte

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

Upaya awal saya di mana setiap baris adalah palindrome. Saya tidak berpikir bahwa ini perlu untuk tantangan ini, tetapi saya memasukkannya untuk berjaga-jaga.

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

Cobalah online!

Befunge , 37 byte

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

Cobalah online!

Baris teratas mendorong dan mencetak setiap karakter input. Baris kedua (sebelum @) mencetak stack secara terbalik, tetapi kita masukkan di contional _untuk mengkonsumsi -1 yang dihasilkan ketika selesai membaca input. Bagian lain dari kode (termasuk baris baru yang jelek) membuat sumber palindrom, tetapi nevers berjalan.

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

disimpan 2 byte untuk penggunaan .Aggregate ()

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

Oh, lambda tua yang baik, kau bisa menangkapnya

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

dan kemudian menyebutnya dengan

f("neverod")

Perl, 45 byte

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

Cukup mudah, printinput ( $_=<>) diikuti oleh reverseitu. reversekembali $_karena kita menggunakannya dalam konteks skalar dengan awalan ~~. Kemudian kami mencocokkan ( m//menggunakan ;sebagai pembatas), dalam konteks kosong, dengan kebalikan dari skrip.

Jika kami dapat menjamin, kami tidak perlu membuat palindrome, esrever,><=_$tnirpkami dapat mempersingkat kode menjadi 43 byte :

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

Pemakaian

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

Perl, 26 byte

Termasuk 25 byte kode +1 untuk -p.

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

Saya tidak berpikir ini valid karena membutuhkan -pbendera yang saya pikir tidak dapat dengan mudah digabungkan ke dalam isi skrip untuk membuat palindrome yang benar. Cukup banyak panggilan yang sama seperti di atas, kecuali itu bergantung pada fakta yang -pjuga menambahkan di ;belakang layar (pada Perls baru ...) untuk menutup m//.

Pemakaian

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

Pyth, 15

 k k+ z_z +k k 

Perhatikan ruang di awal dan di akhir.

Tugas yang cukup menyebalkan di Pyth. z_zmencetak palindrom yang diinginkan, tetapi mencetak z(string input) dan _zkebalikan pada dua garis yang berbeda. +menggabungkan dua kata, tetapi +pada akhirnya membutuhkan dua pernyataan baru di akhir (dan di awal). Saya memilih kdan k, yang hanya string kosong. Kemudian banyak ruang putih, yang menekan pencetakan (dan mencetak ruang kosong, yang menghasilkan jeda baris saja).

Karena ruang putih menekan setiap output kecuali +z_z, Anda dapat mengganti ks dan literal dengan arity 0. Misalnya 1 2+ z_z +2 1atau T Z+ z_z +Z T.

Cobalah online .

Javascript, 137 byte

Saya tidak menggunakan "trik komentar" tetapi saya menggunakan trik tanda kutip yang lolos 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$(=?<

mengambil input dari argumen baris perintah. kutipan untuk multi-kata, lepas baris baru untuk multi-baris.

Python 2, 51 byte

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

Saya terkejut tidak ada yang memikirkan hal ini! Membutuhkan input yang dikutip ( 'atau "). Jika fungsi diizinkan, saya bisa melakukan ini untuk 37 byte:

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

C ++ 14, 152 116 byte

Sebagai lambda yang tidak disebutkan namanya, diasumsikan sdemikianstring

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

Solusi lama:

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

Pemakaian:

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«Â

Cobalah online.

Penjelasan:

        # 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

Atau sebagai alternatif:

R«q«R

Cobalah online.

Di mana Rterbalik, dan« mengambil input secara implisit lagi untuk menyinggung.

CATATAN: Jika kita diizinkan untuk output neverodorevenuntuk input neverod, yang masih merupakan palindrom, itu dapat dilakukan dalam 1 byte sebagai gantinya dengan palindromize builtin:

û

Cobalah online.

x86-64 Majelis (Konvensi pemanggilan Microsoft x64), 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

Dibongkar:

 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

Perhatikan bahwa kode setelah retinstruksi di 2Ctidak dapat dijangkau sehingga tidak masalah bahwa itu omong kosong

Japt , 4 byte

êêêê

Cobalah online!

Bagaimana itu bekerja

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

Alternatif 4 byte

pwwp

Cobalah online!

Bagaimana itu bekerja

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 byte

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

Cobalah online!

Tidak seperti banyak solusi di sini, yang satu ini benar - benar menggunakan kode palindromised!

Penjelasan:

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.

Secara keseluruhan, instruksi yang tidak dieksekusi adalah:

       :   i  o :   |}0~Hi