Wyzwaniem jest tutaj rozszerzenie implementacji palindromu, biorąc pod uwagę następujące dane wejściowe:

• n > 1i listę l.

Twój program musi palindromować listę zarówno pionowo, jak i poziomo, to znaczy najpierw musi palindromować samą listę, a następnie każdy element na liście; Albo na odwrót. Przed palindromizacją wszystkie elementy mają równą długość. Działanie palindromu należy następnie wykonywać nkolejno, aż do uzyskania pożądanego wyniku. Najłatwiejszym sposobem wyświetlenia oczekiwanych wyników jest po prostu kilka przykładów:

Jedna iteracja wykonana dla [123,456,789]:

Najpierw palindromize listę do [123,456,789,456,123].

• Chociaż nie jest to palindrom, jeśli jest ze sobą połączony, jest palindromem pod względem listy.
• [a,b,c]stał się [a,b,c,b,a], więc LISTA była palindromizowana.

Następnie palindromalizujesz każdy element listy [12321,45654,78987,45654,12321].

W ten sposób wykonywana jest każda iteracja, jest to zasadniczo palindrom dookólny.

Biorąc pod uwagę n=1 and l=[123,456,789]:

12321
45654
78987
45654
12321

Dany n=2 and l=[123,456,789]

123212321
456545654
789878987
456545654
123212321
456545654
789878987
456545654
123212321

Biorąc pod uwagę n=1 and l=[3,2,1]:

3
2
1
2
3

Biorąc pod uwagę n=2 and l=["hat","mad"," a "]:

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

Biorąc pod uwagę 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 

Biorąc pod uwagę 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

Biorąc pod uwagę n=3 and l=["_|__","__|_","___|"]:

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

Biorąc pod uwagę n=2 and l=["---|---","__|","___|","____|"]:

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

Zasady

• n zawsze będzie większy niż 1.
• l zawsze będzie mieć więcej niż 1 element.
• Wszystkie elementy lsą tej samej długości.
• To jest najkrótsze rozwiązanie do gry w golfa oznaczone jako zwycięzca.

05AB1E , 4 bajty

Zauważ, że gdyby wymagana była tylko jedna iteracja ( n=1), wówczas program byłby palindromem û€û.

Fû€û

Wypróbuj online

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

Jeśli wypełnienie było nadal wymaganą częścią programu (11 bajtów):

€R.B€RIFû€û

Nie mogłem znaleźć krótszego sposobu uzasadnienia. Lewe justowanie i centrowanie były łatwe, ale z jakiegoś powodu było to dłuższe. Używanie Elub ²zamiast Idziała również.

Python 2 , 71 63 bajtów

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

Wypróbuj online!

Przypisz funkcję palindromu do f, wygeneruj i oceń następujący wzorzec (dla n=4)
f(map(f,f(map(f,f(map(f,f(map(f,<input>))))))))

Galaretka , 6 bajtów

ŒḄŒB$¡

Dyadic link lub pełny program z listą i n.

Wypróbuj online!

Używanie obu wersji fantastycznego wbudowanego „bounce” Lynn.

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

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

Wypróbuj online! - stopka wypisuje każdy element wynikowej listy, po jednym w wierszu, „ładny wydruk”.

h jest funkcją palindomizacji, dołącza do danych wejściowych wszystkie elementy listy od przedostatniego indeksu -2 do początku w krokach wielkości -1.

fwywołań hz wynikiem wywoływania kolejno hkażdego elementu, zmniejsza się no jeden i wywołuje się, aż nosiągnie 0, w którym ato momencie jest gotowy produkt.

APL, 15 bajtów

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

Wyjaśnienie:

• (... )⍣⎕⊢⎕: odczytaj listę i Ndane wejściowe oraz Nczasy działania:
  • ⊢,1↓⌽: lista, po której następuje ogon odwróconej listy
  • Z←: zapisz tę funkcję w Z
  • Z¨: i zastosuj go również do każdego elementu listy

Test:

          (Z¨Z ← ⊢, 1 ↓ ⌽) ⍣⎕⊢⎕ 
    ⎕:
          „hat” „mad” „a”
    ⎕:
          2)
    ┌─────────┬─────────┬─────────┬─────────┬───────── ┬─────────┬─────────┬─────────┬─────────┐
    │hatahatah│madamadam│ aaaa │madamadam│hatahatah│madamadam│ aaaa │madamadam│hatahatah│
    └─────────┴─────────┴─────────┴─────────┴───────── ┴─────────┴─────────┴─────────┴─────────┘

Groovy, 66 bajtów

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

Haskell, 51 bajtów

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

Przykład użycia: ["123","456","789"] ? 1-> ["12321","45654","78987","45654","12321"]. Wypróbuj online! .

(++)<*>reverse.inittworzy palindrom z listy, iterate(...)xpowtarza to wielokrotnie i zbiera wyniki pośrednie z listy, !!nwybiera n-ty element tej listy. (%n)<$>x%ntworzy n-palindrom każdego elementu n-palindromu z x.

JavaScript (ES6), 87 bajtów

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 bajtów

24 bajty kodu, +1 dla -lflagi.

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

Pobiera listę jako argumenty wiersza poleceń i liczbę n od standardowego wejścia. Wypróbuj online!

Wyjaśnienie

                          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)