13

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

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

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

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.

code-golf

— Magic Octopus Urn
quelle

9

Dies wäre eine bessere Herausforderung, wenn wir keine Elemente auffüllen müssten.

— mbomb007

2

@ JonathanAllan Es ist ein omnidirektionales Palindrom oder 2D-Palindrom, könnte man sagen. Ich habe die Beschreibung aktualisiert. Außerdem verhindert die Polsterung einige ungewöhnliche Randfälle, bei denen eine kleinere Saite bereits ein Palindrom ist.

— Magic Octopus Urn

1

@JonathanAllan es ist in Bezug auf die Liste, wenn Sie die Liste als das Element betrachten, das palindromisiert werden soll. Genau wie [@ 1, @ 2, @ 1] ist auch ein Palindrom, wenn man es als Liste betrachtet, nicht nach den Elementen ...

— Magic Octopus Urn

1

@ JonathanAllan Ja, im Wesentlichen können Sie es so ansehen, wenn Sie wollen.

— Magic Octopus Urn

1

Letztes Beispiel erfordert Auffüllen.

— Jonathan Allan

9

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.

— mbomb007
quelle

7

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>))))))))

— Stange
quelle

1

Ich denke du meinst zuweisen . Ich glaube nicht, dass Assing ein Verb ist, lol.

— mbomb007

@ mbomb007 welp, Zeit, um mehr Kaffee zu bekommen ~

— Rod

6

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

— Jonathan Allan
quelle

5

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.

— Jonathan Allan
quelle

... und ich vergesse immer noch die f=für rekursive Funktionen, eines Tages werde ich mich erinnern.

— Jonathan Allan

2

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│
    └─────────┴─────────┴─────────┴─────────┴───────── ┴─────────┴─────────┴─────────┴─────────┘

— Marinus
quelle

1

Groovy, 66 Bytes

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

— Magic Octopus Urn
quelle

1

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.

— nimi
quelle

1

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

— Neil
quelle

1

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)

— DLosc
quelle

Pali-n-drome diese Liste

Regeln

05AB1E , 4 Bytes

Python 2 , 71 63 Bytes

Gelee , 6 Bytes

Python 2 , 64 Bytes

APL, 15 Bytes

Groovy, 66 Bytes

Haskell, 51 Bytes

JavaScript (ES6), 87 Byte

Pip , 25 Bytes

Erläuterung