ความท้าทายที่นี่คือการขยายการดำเนินงานของ palindrome ให้ดังต่อไปนี้เป็นปัจจัยการผลิต:

• n > 1lและรายการ

โปรแกรมของคุณจะต้องทำรายชื่อทั้งในแนวตั้งและแนวนอนนั่นคือก่อนอื่นต้องทำรายการของตัวเองจากนั้นองค์ประกอบแต่ละอย่างในรายการหลังจากนั้น หรือวิธีอื่น ๆ ก่อนที่จะทำการปรับให้เป็นสีองค์ประกอบทั้งหมดจะต้องมีความยาวเท่ากัน การดำเนินการ palindrome นั้นจะต้องดำเนินการnครั้งในลำดับจนกว่าจะได้ผลลัพธ์ที่ต้องการ วิธีที่ง่ายที่สุดในการแสดงผลลัพธ์ที่คาดหวังคือการเรียกใช้ผ่านตัวอย่างบางส่วน:

ดำเนินการซ้ำหนึ่งครั้งใน[123,456,789]:

ก่อนอื่นคุณต้องพิจารณารายชื่อ[123,456,789,456,123]ของ

• ในขณะที่นี่ไม่ใช่ palindrome หากรวมเข้าด้วยกันมันเป็น palindrome ในแง่ของรายการ
• [a,b,c]กลายเป็น[a,b,c,b,a]ดังนั้นรายการที่ได้รับการ palindromized

จากนั้นคุณ palindromize [12321,45654,78987,45654,12321]องค์ประกอบแต่ละรายการ

นี่คือวิธีการทำซ้ำแต่ละครั้งมันเป็นหลักที่เป็นทิศทางรอบทิศทาง

ให้n=1 and l=[123,456,789]:

12321
45654
78987
45654
12321

ป.ร. ให้ไว้ n=2 and l=[123,456,789]

123212321
456545654
789878987
456545654
123212321
456545654
789878987
456545654
123212321

ให้n=1 and l=[3,2,1]:

3
2
1
2
3

ให้n=2 and l=["hat","mad"," a "]:

hatahatah
madamadam
 a a a a 
madamadam
hatahatah
madamadam
 a a a a 
madamadam
hatahatah

ให้n=2 and l=[" 3 ","2000"," 100"]:

 3   3 3   3 
2000002000002
100 00100 001
2000002000002
 3   3 3   3 
2000002000002
100 00100 001
2000002000002
 3   3 3   3 

ให้n=4 and l=["3 ","20","1 "]:

3 3 3 3 3 3 3 3 3
20202020202020202
1 1 1 1 1 1 1 1 1
20202020202020202
3 3 3 3 3 3 3 3 3
20202020202020202
1 1 1 1 1 1 1 1 1
20202020202020202
3 3 3 3 3 3 3 3 3
20202020202020202
1 1 1 1 1 1 1 1 1
20202020202020202
3 3 3 3 3 3 3 3 3
20202020202020202
1 1 1 1 1 1 1 1 1
20202020202020202
3 3 3 3 3 3 3 3 3
20202020202020202
1 1 1 1 1 1 1 1 1
20202020202020202
3 3 3 3 3 3 3 3 3
20202020202020202
1 1 1 1 1 1 1 1 1
20202020202020202
3 3 3 3 3 3 3 3 3
20202020202020202
1 1 1 1 1 1 1 1 1
20202020202020202
3 3 3 3 3 3 3 3 3
20202020202020202
1 1 1 1 1 1 1 1 1
20202020202020202
3 3 3 3 3 3 3 3 3

ให้n=3 and l=["_|__","__|_","___|"]:

_|___|_|___|_|___|_|___|_
__|_|___|_|___|_|___|_|__
___|_____|_____|_____|___
__|_|___|_|___|_|___|_|__
_|___|_|___|_|___|_|___|_
__|_|___|_|___|_|___|_|__
___|_____|_____|_____|___
__|_|___|_|___|_|___|_|__
_|___|_|___|_|___|_|___|_
__|_|___|_|___|_|___|_|__
___|_____|_____|_____|___
__|_|___|_|___|_|___|_|__
_|___|_|___|_|___|_|___|_
__|_|___|_|___|_|___|_|__
___|_____|_____|_____|___
__|_|___|_|___|_|___|_|__
_|___|_|___|_|___|_|___|_

ให้n=2 and l=["---|---","__|","___|","____|"]:

---|-----|-----|-----|---
  __|   |__   __|   |__  
 ___|   |___ ___|   |___ 
 ____| |____ ____| |____ 
 ___|   |___ ___|   |___ 
  __|   |__   __|   |__  
---|-----|-----|-----|---
  __|   |__   __|   |__  
 ___|   |___ ___|   |___ 
 ____| |____ ____| |____ 
 ___|   |___ ___|   |___ 
  __|   |__   __|   |__  
---|-----|-----|-----|---

กฎระเบียบ

• n จะมากกว่า 1
• l จะมีองค์ประกอบมากกว่า 1 รายการเสมอ
• องค์ประกอบทั้งหมดของlมีความยาวเท่ากัน
• นี่คือการแก้ปัญหาที่สั้นที่สุดของcode-golfจะถูกทำเครื่องหมายเป็นผู้ชนะ

05AB1E , 4 ไบต์

โปรดทราบว่าถ้าเพียงย้ำเดียวที่ถูกต้อง ( n=1) จากนั้นโปรแกรมจะ û€ûpalindrome

Fû€û

ลองออนไลน์

F       Do n times
 û      Palindromize the list
  €û    Palindromize each element in the list

หากการเติมอินพุตยังคงเป็นส่วนที่ต้องการของโปรแกรม (11 ไบต์):

€R.B€RIFû€û

ฉันไม่สามารถหาวิธีที่เหมาะสมในการจัดชิดขวา การจัดชิดขอบซ้ายและการตั้งศูนย์ทำได้ง่ายทั้งหมด แต่นี่ก็นานกว่าด้วยเหตุผลบางอย่าง การใช้Eหรือ²แทนที่จะใช้Iงานได้

Python 2 , 71 63 ไบต์

lambda x,n,f=lambda x:x+x[-2::-1]:eval('f(map(f,'*n+`x`+'))'*n)

ลองออนไลน์!

กำหนดฟังก์ชัน palindrome ให้กับfสร้างและประเมินรูปแบบต่อไปนี้ (สำหรับn=4)
f(map(f,f(map(f,f(map(f,f(map(f,<input>))))))))

เยลลี่ขนาด 6 ไบต์

ŒḄŒB$¡

การเชื่อมโยง dyadic nหรือโปรแกรมเต็มรูปแบบการรายการและ

ลองออนไลน์!

การใช้ "เด้ง" ในตัวทั้งสองเวอร์ชันของลินน์ที่ยอดเยี่ยม

ŒḄŒB$¡ - Main link: l, n
     ¡ - repeat n times
    $  -     last two links as a monad (firstly with l then the result...)
ŒḄ     -         bounce ("palindromise") the list
  ŒB   -         bounce the elements

Python 2 , 64 ไบต์

h=lambda a:a+a[-2::-1]
f=lambda a,n:n and f(h(map(h,a)),n-1)or a

ลองออนไลน์! - ส่วนท้ายพิมพ์แต่ละองค์ประกอบของรายการผลลัพธ์หนึ่งรายการต่อบรรทัด "พิมพ์สวย"

h เป็นฟังก์ชั่น palindomisation มันผนวกเข้ากับองค์ประกอบทั้งหมดของรายการจากที่ผ่านมา แต่หนึ่งดัชนี -2 เพื่อเริ่มต้นในขั้นตอนของขนาด -1

fการโทรhด้วยผลลัพธ์ของการโทรhไปยังแต่ละองค์ประกอบจะลดลงทีnละหนึ่งและเรียกตัวเองจนกระทั่งnถึง 0 ซึ่งaเป็นจุดที่ผลิตภัณฑ์สำเร็จรูป

APL, 15 ไบต์

(Z¨Z←⊢,1↓⌽)⍣⎕⊢⎕

คำอธิบาย:

• (... )⍣⎕⊢⎕: อ่านรายการและNเป็นอินพุตและNเวลารัน:
  • ⊢,1↓⌽: รายการตามด้วยส่วนท้ายของรายการที่กลับรายการ
  • Z←: เก็บฟังก์ชันนี้ไว้ Z
  • Z¨: และนำไปใช้กับองค์ประกอบของรายการแต่ละรายการเช่นกัน

ทดสอบ:

          (ZZ ←⊢ 1 ↓⌽) ⍣⎕⊢⎕ 
    ⎕:
          'hat' 'mad' 'a'
    ⎕:
          2
    ┌─────────┬─────────┬─────────┬─────────┬───────── ┬─────────┬─────────┬─────────┬─────────┐
    │hatahatah│madamadam│ aaaa │madamadam│hatahatah│madamadam│ aaaa │madamadam│hatahatah│
    └─────────┴─────────┴─────────┴─────────┴───────── ┴─────────┴─────────┴─────────┴─────────┘

Groovy, 66 ไบต์

{x,n->f={z->z+z[z.size()-2..0]};n.times{x=f(x).collect{f(it)}};x}

Haskell, 51 ไบต์

x%n=iterate((++)<*>reverse.init)x!!n
x?n=(%n)<$>x%n

ตัวอย่างการใช้งาน: ->["123","456","789"] ? 1 ลองออนไลน์! .["12321","45654","78987","45654","12321"]

(++)<*>reverse.initทำ palindrome ออกจากรายการiterate(...)xทำซ้ำอีกครั้งและอีกครั้งและรวบรวมผลลัพธ์ระดับกลางในรายการ!!nเลือกองค์ประกอบที่ n ของรายการนี้ (%n)<$>x%nทำให้ N-palindrom ขององค์ประกอบของ n-palindrome xของแต่ละ

JavaScript (ES6), 87 ไบต์

f=(n,l,r=l=>[...a].reverse().slice(1))=>n--?f(l.concat(r(l)).map(s=>s+r(s).join``),n):l

Pip , 25 ไบต์

โค้ดขนาด 24 ไบต์ +1 สำหรับการ-lตั้งค่าสถานะ

Lq{gM:_.@>RV_gAL:@>RVg}g

รับรายการเป็นอาร์กิวเมนต์บรรทัดคำสั่งและหมายเลขnจาก stdin ลองออนไลน์!

คำอธิบาย

                          g is list of cmdline args (implicit)
Lq{                   }   Read a line of input and loop that many times:
      _.@>RV_             Lambda function: take all but the first character (@>) of the
                           reverse (RV) of the argument (_), and concatenate that (.) to
                           the argument (_)
   gM:                    Map this function to g and assign the result back to g
                 @>RVg    Take all but the first element of the reverse of g
             gAL:         Append that list to g and assign the result back to g
                       g  After the loop, print g (each item on its own line due to -l)