Tạo một chương trình, chuyển đổi chuỗi đầu vào thành một palindrom bắt đầu bằng chuỗi đầu vào. Chương trình phải là một palindrom.

Ví dụ đầu vào : neverod, in neveroddoreven. Bạn nên xử lý đầu vào nhiều từ, nhiều dòng là tốt.

Thuốc nhuộm APL, 6 4

⌽,,⌽

Hãy thử nó ở đây.

Các giải pháp khác:

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

Giải trình

Họ chỉ là:

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

Monadic ,và ⊢không làm gì trên chuỗi. Dyadic ,là nối. Dyadic ⊢trả về toán hạng bên phải của nó. Và ⌽rõ ràng là sự đảo ngược.

piet 19x2 = 38

Chấp nhận đầu vào cho đến khi gặp 0x00. Không chấm dứt, nhưng đầu ra sẽ chính xác.

APL, 9

⍞←Z,⌽,Z←⍞

Giải trình:

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

Dùng thử trực tuyến tại đây

hoặc là..

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

Hãy thử nó ở đây

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

Điều này phải được chạy với Control.Applicativemô-đun trong phạm vi, có thể được đặt qua tệp ghci init .ghci: :m Control.Applicative(-> +22 byte).

Không có mẹo nhận xét, chỉ có 7 chức năng trong đó 4 trong số chúng không bao giờ được gọi.

Nếu các chức năng (thay vì chương trình) được cho phép:

Haskell, 55 + 22 = 77 byte

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

Cách sử dụng f "qwer"->"qwerrewq"

Chỉnh sửa: phiên bản trước chỉ sai.

Bình thường, 11 byte

+z_z " z_z+

Trong Pyth, mọi thứ trước một khoảng trắng đều không được in. Vì vậy, chúng tôi chỉ cần thêm tiêu cực của chuỗi vào chính nó, đặt dấu cách, bắt đầu chuỗi và phản chiếu phía bên trái của trích dẫn "

Dùng thử trực tuyến tại đây

Hồng ngọc, 44

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

Lấy một chuỗi nhiều dòng làm đầu vào từ stdin, đưa ra một đại diện Ruby của chuỗi đó được nối với đảo ngược của nó. Có thể cắt một ký tự bằng cách thay thế ||bằng #để nhận xét mã chết trên dòng thứ hai.

Jolf, 9 byte

Ngôn ngữ mới hơn, không cạnh tranh

Thử ở đây

aη+i_i+ηa

Giải thích: Tôi chỉ mới bắt đầu Jolf và tôi không nghĩ mình đang giải thích điều này đúng.

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$

Dùng thử trực tuyến

Theo đề xuất của @mazzy, mã có thể được rút ngắn 12 byte khi sử dụng phạm vi tĩnh. Tuy nhiên, điều này giới hạn độ dài đầu vào là 9KBytes. Về mặt lý thuyết, 9MBytes là có thể nhưng nó sẽ làm chậm mã đáng kể.

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

Fuzzy Octo Guacamole, 17 byte

_{FOG mới hơn thử thách này, vì vậy đây không phải là đối thủ.}

^dz''sjX@Xjs''zd^

Giải pháp thay thế trong 19 byte:

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

Cả hai đều nhận đầu vào, trùng lặp và đảo ngược và tham gia ngăn xếp.

Giải trình:

^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

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

Suy nghĩ đầu tiên của tôi là Brainfuck, nhưng không thể phù hợp với niềng răng ... may mắn thay, tinyBF có khả năng kiểm soát dòng chảy đơn giản hơn.

Không có ý kiến, nó lấy một chuỗi kết thúc null làm đầu vào và trả về kết quả trong một chuỗi kết thúc null. Bạn có thể kiểm tra nó ở đây , chỉ cần báo trước rằng nó không dừng lại (mặc dù Firefox ít nhất nhắc nhở dừng tập lệnh không phản hồi).

Đã bình luận:

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

Lưu ý rằng nếu bạn mã hóa nó thành các hướng dẫn 2 bit, nó sẽ cắt kích thước xuống còn 10 byte (sẽ không phải là một bảng màu).

Python 3, 59 byte

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

Tôi đã cố gắng hết sức để tìm một giải pháp chỉ sử dụng một dòng nhưng tôi không gặp may.

Python 3, 79 byte

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

Nỗ lực ban đầu của tôi trong đó mỗi dòng là một palindrom. Tôi không nghĩ rằng nó là cần thiết cho thử thách này, nhưng tôi đã bao gồm nó chỉ trong trường hợp.

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

Hãy thử trực tuyến!

Befunge , 37 byte

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

Hãy thử trực tuyến!

Dòng trên cùng đẩy và in mọi ký tự đầu vào. Dòng thứ hai (trước @) in ngăn xếp ngược lại, nhưng chúng ta nhập vào liên kết _để tiêu thụ -1 được tạo khi đọc xong đầu vào. Nửa còn lại của mã (bao gồm cả những dòng mới xấu xí) làm cho nguồn trở thành một bảng màu, nhưng không bao giờ chạy.

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

đã lưu 2 byte khi sử dụng .Aggregate ()

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

Oh lambda tốt, bạn có thể bắt nó với

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

và sau đó gọi nó với

f("neverod")

Perl, 45 byte

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

Khá đơn giản, prints đầu vào ( $_=<>) theo sau là reversecủa nó. reversetrả về $_vì chúng tôi đang sử dụng nó trong ngữ cảnh vô hướng bằng cách thêm tiền tố vào ~~. Sau đó, chúng tôi phù hợp ( m//sử dụng; như dấu phân cách), trong bối cảnh void, ngược lại với kịch bản ngược lại.

Nếu chúng ta có thể bảo đảm, chúng ta sẽ không phải tạo một bảng màu, esrever,><=_$tnirpchúng ta có thể rút ngắn mã thành 43 byte :

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

Sử dụng

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

Perl, 26 byte

Bao gồm 25 byte mã + 1 cho -p.

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

Tôi không nghĩ rằng điều này là hợp lệ vì nó yêu cầu -pcờ mà tôi không nghĩ có thể dễ dàng kết hợp vào nội dung tập lệnh để tạo ra một bảng màu thực sự. Khá nhiều cuộc gọi tương tự như trên, ngoại trừ việc nó dựa vào thực tế -pcũng thêm một ;hậu trường (trên Perls mới hơn ...) để đóngm// .

Sử dụng

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

Bình thường, 15

 k k+ z_z +k k 

Chú ý không gian ở đầu và cuối.

Nhiệm vụ khá khó chịu trong Pyth. z_zin bảng màu mong muốn, nhưng nó in z(chuỗi đầu vào) và _znghịch đảo trên hai dòng khác nhau. +kết hợp hai từ, nhưng +ở cuối yêu cầu hai câu mới ở cuối (và ở đầu). Tôi chọn kvàk , đó chỉ là các chuỗi trống. Sau đó, rất nhiều khoảng trắng, ngăn chặn việc in (và in các khoảng trống, tạo ra các ngắt dòng tất nhiên).

Vì khoảng trắng ngăn chặn mọi đầu ra ngoại trừ +z_z, bạn có thể thay thế ks và nghĩa đen bằng arity 0. Ví dụ 1 2+ z_z +2 1hoặc T Z+ z_z +Z T.

Hãy thử trực tuyến .

Javascript, 137 byte

Tôi không sử dụng "mẹo bình luận" nhưng tôi đang sử dụng thủ thuật đánh dấu dấu ngoặc kép đã thoát.

"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$(=?<

lấy đầu vào từ đối số dòng lệnh. trích dẫn cho nhiều từ, thoát dòng mới cho nhiều dòng.

Python 2, 51 byte

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

Tôi ngạc nhiên không ai nghĩ về điều này! Nhu cầu trích dẫn đầu vào ( 'hoặc "). Nếu các chức năng được cho phép, tôi có thể đã thực hiện điều này trong 37 byte thay thế:

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

C ++ 14, 152 116 byte

Như lambda chưa được đặt tên, giả sử slà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(][

Giải pháp cũ:

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

Sử dụng:

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

Hãy thử trực tuyến.

Giải trình:

        # 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

Hay cách khác:

R«q«R

Hãy thử trực tuyến.

Trường hợp Rngược lại, và «đầu vào hoàn toàn một lần nữa để nối với.

LƯU Ý: Nếu chúng tôi được phép xuất ra neverodorevencho đầu vào neverod, vẫn là một bảng màu, nó có thể được thực hiện trong 1 byte thay vì được dựng sẵn palindromize:

û

Hãy thử trực tuyến.

Hội x86-64 (quy ước gọi 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

Đã tháo rời:

 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

Lưu ý rằng mã sau rethướng dẫn tại 2Ckhông thể truy cập được nên không quan trọng là nó vô nghĩa

Japt , 4 byte

êêêê

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte thay thế

pwwp

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Trái tay , 33 27 byte

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

Hãy thử trực tuyến!

Không giống như rất nhiều giải pháp ở đây, cái này thực sự không sử dụng mã palindromised!

Giải trình:

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.

Nhìn chung, các hướng dẫn chưa được thực hiện là:

       :   i  o :   |}0~Hi