Die Herausforderung besteht hier darin, eine Implementierung von Palindrom unter Berücksichtigung der folgenden Eingaben zu erweitern:

• n > 1und eine Liste l.

Ihr Programm muss die Liste sowohl vertikal als auch horizontal palindromieren, dh es muss zuerst die Liste selbst palindromieren und dann jedes Element in der Liste danach. oder umgekehrt. Vor der Palindromisierung wird sichergestellt, dass alle Elemente gleich lang sind. Die Palindrom-Aktion muss dann nnacheinander ausgeführt werden, bis die gewünschte Ausgabe erreicht ist. Die einfachste Möglichkeit, die erwarteten Ausgaben anzuzeigen, besteht darin, einige Beispiele durchzugehen:

Eine Iteration durchgeführt am [123,456,789]:

Zuerst palindromisieren Sie die Liste zu [123,456,789,456,123].

• Während dies kein Palindrom ist, wenn es zusammengefügt wird, ist es in Bezug auf die Liste ein Palindrom.
• [a,b,c]wurde [a,b,c,b,a], so wurde die LIST palindromisiert.

Anschließend palindromisieren Sie jedes Listenelement [12321,45654,78987,45654,12321].

So wird jede Iteration durchgeführt, es ist im Wesentlichen ein omnidirektionales Palindrom.

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

12321
45654
78987
45654
12321

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

123212321
456545654
789878987
456545654
123212321
456545654
789878987
456545654
123212321

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

3
2
1
2
3

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

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

Gegeben 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 

Gegeben 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

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

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

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

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

Regeln

• n wird immer größer als 1 sein.
• l wird immer mehr als 1 Element haben.
• Alle Elemente von lsind gleich lang.
• Dies ist Code-Golf kürzeste Lösung wird als Gewinner markiert.

05AB1E , 4 Bytes

Beachten Sie, dass n=1das Programm das Palindrom ist , wenn nur eine einzige Iteration erforderlich ist ( ) û€û.

Fû€û

Probieren Sie es online aus

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

Wenn das Auffüllen der Eingabe noch ein erforderlicher Teil des Programms war (11 Bytes):

€R.B€RIFû€û

Ich konnte keinen kürzeren Weg finden, um richtig zu rechtfertigen. Linksbündigkeit und Zentrierung waren alle einfach, aber dies war aus irgendeinem Grund länger. Verwenden von Eoder ²anstelle von Ifunktioniert auch.

Python 2 , 71 63 Bytes

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

Probieren Sie es online!

Weisen Sie eine Palindrom-Funktion zu f, generieren und bewerten Sie das folgende Muster (für n=4)
f(map(f,f(map(f,f(map(f,f(map(f,<input>))))))))

Gelee , 6 Bytes

ŒḄŒB$¡

Dyadic Link oder komplettes Programm unter der Liste und n.

Probieren Sie es online!

Mit beiden Versionen von Lynns fantastischem eingebautem "Bounce".

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

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

Probieren Sie es online! - footer druckt jedes Element der resultierenden Liste aus, eines pro Zeile, ein "hübscher Ausdruck".

h Wenn es sich um die Palindomisierungsfunktion handelt, werden alle Elemente einer Liste vom vorletzten Index -2 bis zum Anfang in Schritten der Größe -1 an die Eingabe angehängt.

fruft hmit dem Ergebnis des Aufrufs hjedes Elements abwechselnd auf, reduziert sich num eins und ruft sich selbst auf, bis n0 erreicht ist, an welchem ​​Punkt adas fertige Produkt ist.

APL, 15 Bytes

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

Erläuterung:

• (... )⍣⎕⊢⎕: lies die Liste und Nals Eingabe, und laufe Nmal:
  • ⊢,1↓⌽: die Liste, gefolgt vom Ende der umgekehrten Liste
  • Z←: Speichern Sie diese Funktion in Z
  • Z¨: und wende es auch auf jedes Element der Liste an

Prüfung:

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

Groovy, 66 Bytes

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

Haskell, 51 Bytes

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

Anwendungsbeispiel: ["123","456","789"] ? 1-> ["12321","45654","78987","45654","12321"]. Probieren Sie es online! .

(++)<*>reverse.initmacht aus einer Liste ein Palindrom, iterate(...)xwiederholt dies immer wieder und sammelt die Zwischenergebnisse in einer Liste, !!nwählt das n-te Element dieser Liste aus. (%n)<$>x%nmacht aus jedem Element des n-Palindroms von ein n-Palindrom x.

JavaScript (ES6), 87 Byte

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 Bytes

24 Byte Code, +1 für -lFlag.

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

Übernimmt die Liste als Befehlszeilenargumente und die Nummer n aus stdin. Probieren Sie es online!

Erläuterung

                          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)