สร้างโปรแกรมที่แปลงสตริงอินพุตเป็น palindrome เริ่มต้นด้วยสตริงอินพุต ตัวโปรแกรมเองจะต้องเป็นแบบ palindrome

ยกตัวอย่างเช่นการป้อนข้อมูล: พิมพ์neverod neveroddorevenคุณควรจัดการอินพุตแบบหลายคำหลายบรรทัดเช่นกัน

Dyalog APL, 6 4

⌽,,⌽

ลองที่นี่

โซลูชั่นอื่น ๆ :

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

คำอธิบาย

พวกเขาเป็นเพียง:

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

Monadic ,และ⊢ไม่ได้ทำอะไรกับสตริง 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 สิ่งใดก็ตามที่มีช่องว่างก่อนหน้าจะไม่ถูกพิมพ์ ดังนั้นเราเพียงแค่เพิ่มการลบของสตริงให้กับตัวเองใส่ช่องว่างเริ่มสตริงและสะท้อนด้านซ้ายของคำพูด "

ลองออนไลน์ได้ที่นี่

ทับทิม, 44

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

รับสตริง multiline เป็นอินพุตจาก stdin ส่งเอาต์พุตการแทน Ruby ของสตริงนั้นที่ต่อกันเป็น reverse สามารถตัดแต่งอักขระโดยแทนที่||ด้วย#เพื่อคอมเม้นต์โค้ดที่ตายแล้วในบรรทัดที่สอง

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 ไบต์เมื่อใช้ช่วงแบบคงที่ อย่างไรก็ตามสิ่งนี้จำกัดความยาวของอินพุตไว้ที่ 9KBytes ในทางทฤษฎีจะเป็นไปได้ 9MBytes แต่มันจะชะลอตัวรหัสอย่างมีนัยสำคัญ

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

Fuzzy Octo Guacamole, 17 ไบต์

_{FOG นั้นใหม่กว่าความท้าทายนี้ดังนั้นจึงไม่ใช่การแข่งขัน}

^dz''sjX@Xjs''zd^

โซลูชัน Alt ในขนาด 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 มีการควบคุมการไหลที่ง่ายขึ้น

ไม่มีความคิดเห็นมันต้องใช้สตริงที่สิ้นสุดด้วยค่า null เป็นอินพุตและส่งคืนผลลัพธ์ในสตริงที่สิ้นสุดด้วยค่า null คุณสามารถทดสอบได้ที่นี่เพียง แต่ได้รับการเตือนล่วงหน้าว่าจะไม่หยุด (แม้ว่าอย่างน้อย 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 ไบต์ (จะไม่เป็น Palindrome)

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

ลองออนไลน์!

บรรทัดบนสุดดันและพิมพ์อักขระทุกตัวของอินพุต บรรทัดที่สอง (ก่อนหน้า@) พิมพ์สแต็กในสิ่งที่ตรงกันข้าม แต่เราป้อนที่ contional _เพื่อใช้ -1 ที่สร้างเมื่อเสร็จสิ้นการอ่านอินพุต อีกครึ่งหนึ่งของรหัส (รวมถึงการขึ้นบรรทัดใหม่ต่อท้ายน่าเกลียด) ทำให้แหล่งข้อมูลเป็น palindrome แต่ nevers ทำงาน

C # ( 33 32 + 1) * 2 = 68 66 ไบต์

บันทึก 2 ไบต์ไปยังการใช้. Agregate ()

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ผลตอบแทน$_เพราะเรากำลังใช้มันในบริบทเกลาโดย prefixing ~~ด้วย จากนั้นเราจับคู่ ( m//ใช้;เป็นตัวคั่น) ในบริบทที่เป็นโมฆะตรงข้ามกับสคริปต์

หากเราสามารถรับประกันได้เราจะไม่ต้องสร้าง palindrome ของ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ตั้งค่าสถานะซึ่งฉันคิดว่าไม่สามารถรวมเข้ากับเนื้อหาของสคริปต์เพื่อสร้าง palindrome ที่แท้จริงได้อย่างง่ายดาย ค่อนข้างโทรเหมือนเดิมข้างต้นยกเว้นมันขึ้นอยู่กับความจริงที่ว่า-pยังเพิ่ม;เบื้องหลัง (บน Perls รุ่นใหม่ ... ) เพื่อปิดm//เพื่อปิด

การใช้

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

Pyth, 15

 k k+ z_z +k k 

สังเกตุช่องว่างที่จุดเริ่มต้นและตอนท้าย

ค่อนข้างน่ารำคาญใน Pyth z_zพิมพ์ palindrome ที่ต้องการ แต่จะพิมพ์z(สตริงอินพุต) และ_zผกผันในสองบรรทัดที่แตกต่างกัน +รวมคำสองคำเข้าด้วยกัน แต่+ท้ายที่สุดจะต้องมีสองประโยคใหม่ที่ตอนท้าย ฉันเลือกkและkซึ่งเป็นเพียงสตริงที่ว่างเปล่า จากนั้นมีพื้นที่สีขาวจำนวนมากซึ่งระงับการพิมพ์ (และการพิมพ์พื้นที่ว่างเปล่าซึ่งสร้างการแบ่งบรรทัด)

เนื่องจากพื้นที่สีขาวระงับการส่งออกทุกยกเว้น+z_zคุณสามารถแทนที่kและตัวอักษรกับ arity 0. เช่นหรือ1 2+ z_z +2 1T 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 bytes

แลมบ์ดาที่ไม่มีชื่อก็ถือว่า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

ลองออนไลน์

Rจะกลับที่ไหนและ«นำเข้าโดยปริยายอีกครั้งเพื่อเชื่อมโยงกับ

หมายเหตุ: หากเราได้รับอนุญาตให้ส่งออกneverodorevenสำหรับอินพุตneverodซึ่งยังคงเป็น palindrome ก็สามารถทำได้ใน1 ไบต์แทนด้วย palindromize builtin:

û

ลองออนไลน์

แอสเซมบลี 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