Buradaki zorluk, girdi olarak aşağıda verilen palindrom uygulamasını genişletmektir:

• n > 1ve bir liste l.

Programınız listeyi hem dikey hem de yatay olarak palindrom etmelidir, yani önce listenin kendisini, daha sonra listedeki her öğeyi palindrom etmelidir; ya da başka bir şekilde. Palindromizasyondan önce, tüm elemanların eşit uzunlukta olması sağlanır. Ardından palindrom eylemi, nistenen çıktı karşılanana kadar sırayla gerçekleştirilecektir . Beklenen çıktıları göstermenin en kolay yolu sadece birkaç örnek üzerinden çalışmaktır:

Bir yineleme [123,456,789]:

Önce listeyi palindromize edersiniz [123,456,789,456,123].

• Bu bir araya getirilirse bir palindrom olmasa da, liste açısından bir palindromdur.
• [a,b,c]oldu [a,b,c,b,a]LİSTESİ palindromized bu yüzden.

Ardından, her liste öğesini palindromize edersiniz [12321,45654,78987,45654,12321].

Her yineleme böyle yapılır, aslında çok yönlü bir palindrom.

Verilen n=1 and l=[123,456,789]:

12321
45654
78987
45654
12321

verilmiş n=2 and l=[123,456,789]

123212321
456545654
789878987
456545654
123212321
456545654
789878987
456545654
123212321

Verilen n=1 and l=[3,2,1]:

3
2
1
2
3

Verilen n=2 and l=["hat","mad"," a "]:

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

Verilen 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 

Verilen 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

Verilen n=3 and l=["_|__","__|_","___|"]:

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

Verilen n=2 and l=["---|---","__|","___|","____|"]:

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

kurallar

• n her zaman 1'den büyük olacaktır.
• l her zaman 1'den fazla öğeye sahip olacaktır.
• Öğelerinin tüm öğeleri laynı uzunluktadır.
• Bu kod golf en kısa çözüm kazanan olarak işaretlenir.

05AB1E , 4 bayt

Yalnızca tek bir yineleme gerekirse ( n=1), programın palindrom olacağını unutmayın û€û.

Fû€û

Çevrimiçi deneyin

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

Eğer dolgu doldurma hala programın gerekli bir parçasıysa (11 bayt):

€R.B€RIFû€û

Doğru gerekçelendirmenin daha kısa bir yolunu bulamadım. Sola dayalı ve merkezleme kolaydı, ama bu bir nedenden ötürü daha uzundu. Kullanmak Eveya ²yerine Ide çalışır.

Python 2 , 71 63 bayt

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

Çevrimiçi deneyin!

fAşağıdaki modeli (için n=4) bir palindrome işlevi atayın , oluşturun ve değerlendirin
f(map(f,f(map(f,f(map(f,f(map(f,<input>))))))))

Jöle , 6 bayt

ŒḄŒB$¡

Dyadic link veya tam program listesi alarak n.

Çevrimiçi deneyin!

Lynn'in fantastik yerleşik "sıçrama" her iki sürümünü kullanarak.

ŒḄŒ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 bayt

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

Çevrimiçi deneyin! - altbilgi, her bir satırda bir tane olmak üzere, sonuçta ortaya çıkan listenin öğelerinin her birini "güzel yazdır" olarak yazdırır.

h palindomisation fonksiyonudur, girişe, sonuncu bir listeden, dizin -2'den, -1 boyutundaki adımlarla başlangıca kadar tüm elemanları ekler.

faramalar hçağrı sonucu hda her eleman, azaltan ntek kadar ve kendisini aramalar nnoktası, ulaşır 0, abitmiş bir ürün.

APL, 15 bayt

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

Açıklama:

• (... )⍣⎕⊢⎕: listeyi ve Ngirdi olarak ve çalışma Nsürelerini okuyun:
  • ⊢,1↓⌽: liste, ardından ters listenin kuyruğu
  • Z←: bu işlevi Z
  • Z¨: ve listenin her öğesine de uygula

Ölçek:

          (ZZ ← ⊢, 1 ↓ ⌽) ⍣⎕⊢⎕ 
    ⎕:
          'şapka' 'deli' 'a'
    ⎕:
          2
    ┌─────────┬─────────┬─────────┬─────────┬───────── ┬─────────┬─────────┬─────────┬─────────┐
    Tahatahatah│madamadam│ aaaa │madamadam│hatahatah│madamadam│ aaaa │madamadam│hatahatah│
    └─────────┴─────────┴─────────┴─────────┴───────── ┴─────────┴─────────┴─────────┴─────────┘

Groovy, 66 bayt

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

Haskell, 51 bayt

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

Kullanım örneği: ["123","456","789"] ? 1-> ["12321","45654","78987","45654","12321"]. Çevrimiçi deneyin! .

(++)<*>reverse.initlisteden bir palindrom yapar, iterate(...)xbunu tekrar tekrar tekrarlar ve ara sonuçları bir listede toplar, !!nbu listenin n. öğesini seçer. (%n)<$>x%nn-palindromunun her elemanının bir n-palindromunu yapar x.

JavaScript (ES6), 87 bayt

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 bayt

24 bayt kod, -lbayrak için +1 .

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

Listeyi komut satırı argümanları ve stdin'den n sayısı alır. Çevrimiçi deneyin!

açıklama

                          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)