13

Le défi ici consiste à étendre une implémentation du palindrome compte tenu des éléments suivants en entrée:

n > 1et une liste l.

Votre programme doit palindrome la liste à la fois verticalement et horizontalement, c'est-à-dire qu'il doit d'abord palindrome la liste elle-même, puis chaque élément de la liste après; ou l'inverse. Avant la palindromisation, tous les éléments sont garantis de longueur égale. L'action palindrome doit alors être exécutée plusieurs nfois de suite jusqu'à ce que la sortie souhaitée soit atteinte. Le moyen le plus simple d'afficher les résultats attendus consiste simplement à parcourir quelques exemples:

Une itération effectuée sur [123,456,789]:

Commencez par palindromiser la liste [123,456,789,456,123].

Bien que ce ne soit pas un palindrome s'il est réuni, c'est un palindrome en termes de liste.
[a,b,c]est devenu [a,b,c,b,a], donc la LISTE a été palindromisée.

Ensuite, vous palindromisez chaque élément de la liste [12321,45654,78987,45654,12321].

C'est ainsi que chaque itération est effectuée, c'est essentiellement un palindrome omnidirectionnel.

Étant donné n=1 and l=[123,456,789]:

Donné n=2 and l=[123,456,789]

Étant donné n=1 and l=[3,2,1]:

Étant donné n=2 and l=["hat","mad"," a "]:

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

Étant donné 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

Étant donné 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

Étant donné n=3 and l=["_|__","__|_","___|"]:

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

Étant donné n=2 and l=["---|---","__|","___|","____|"]:

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

Règles

n sera toujours supérieur à 1.
l aura toujours plus d'un élément.
Tous les éléments de lsont de la même longueur.
Il s'agit de la solution la plus courte de code-golf qui sera marquée comme gagnante.

code-golf

— Urne de poulpe magique
source

9

Ce serait un meilleur défi si nous n'avions pas à remplir les éléments.

— mbomb007

2

@JonathanAllan c'est un palindrome omnidirectionnel, ou palindrome 2D pourrait-on dire. J'ai mis à jour la description; De plus, le rembourrage empêche quelques cas de franges étranges où une chaîne plus petite est déjà un palindrome.

— Urne de poulpe magique

1

@JonathanAllan c'est en termes de liste, si vous regardez la LISTE comme l'élément à palindromiser. Tout comme [@ 1, @ 2, @ 1] est également un palindrome quand on le regarde comme une liste, pas par les éléments ...

— Urne Magic Octopus

1

@JonathanAllan oui, essentiellement, vous pouvez le voir comme ça si vous le souhaitez.

— Urne de poulpe magique

1

Le dernier exemple nécessite un remplissage.

— Jonathan Allan

9

05AB1E , 4 octets

Notez que si une seule itération était requise ( n=1), le programme serait le palindrome û€û.

Fû€û

Essayez-le en ligne

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

Si le remplissage de l'entrée faisait toujours partie du programme (11 octets):

€R.B€RIFû€û

Je n'ai pas pu trouver un moyen plus court de justifier à droite. La justification à gauche et le centrage étaient tous faciles, mais c'était plus long pour une raison quelconque. Utiliser Eou ²au lieu de Ifonctionne également.

— mbomb007
source

7

Python 2 , 71 63 octets

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

Essayez-le en ligne!

Attribuer une fonction palindrome à f, générer et évaluer le motif suivant (pour n=4)
f(map(f,f(map(f,f(map(f,f(map(f,<input>))))))))

— Barre
source

1

Je pense que vous voulez dire assigner . Je ne pense pas qu'assing est un verbe, lol.

— mbomb007

@ mbomb007 welp, il est temps d'obtenir plus de café ~

— Rod

6

Gelée , 6 octets

ŒḄŒB$¡

Lien dyadique, ou programme complet reprenant la liste et n .

Essayez-le en ligne!

Utilisation des deux versions du fantastique "rebond" intégré de 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

— Jonathan Allan
source

5

Python 2 , 64 octets

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

Essayez-le en ligne! - footer imprime chacun des éléments de la liste résultante, un par ligne, une "jolie impression".

h est la fonction de palindomisation, elle ajoute à l'entrée, tous les éléments d'une liste du dernier sauf un, index -2, au début par pas de taille -1.

fappelle havec le résultat d'appeler hà tour de rôle chaque élément, réduit nde un et s'appelle jusqu'à ce qu'il natteigne 0, auquel point ale produit fini.

— Jonathan Allan
source

... et j'oublie toujours les f=fonctions récursives, un jour je m'en souviendrai.

— Jonathan Allan

2

APL, 15 octets

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

Explication:

(... )⍣⎕⊢⎕: lire la liste et Nen entrée, et exécuterN temps d' :
- ⊢,1↓⌽: la liste, suivie de la fin de la liste inversée
- Z←: stocker cette fonction dans Z
- Z¨: et l'appliquer également à chaque élément de la liste

Tester:

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

— marinus
source

1

Groovy, 66 octets

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

— Urne de poulpe magique
source

1

Haskell, 51 octets

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

Exemple d'utilisation: ["123","456","789"] ? 1-> ["12321","45654","78987","45654","12321"]. Essayez-le en ligne! .

(++)<*>reverse.initcrée un palindrome à partir d'une liste, le iterate(...)xrépète encore et encore et recueille les résultats intermédiaires dans une liste, !!nsélectionne le nième élément de cette liste. (%n)<$>x%nfait un n-palindrome de chaque élément du n-palindrome de x.

— nimi
source

1

JavaScript (ES6), 87 octets

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

— Neil
source

1

Pip , 25 octets

24 octets de code, +1 pour l' -lindicateur.

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

Prend la liste comme arguments de ligne de commande et le nombre n de stdin. Essayez-le en ligne!

Explication

                          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
source

Pali-n-drome cette liste