Dans ce défi, vous devez apporter de l'art ASCII (qui sont généralement 2D) à la 3D!

Comment?

comme ça,

X X DD 
 X  D D
X X DD 

à...

  X X DD 
 X X DD D
X X DDDD 
 X XDDD
X X DD

Alors comment on fait ça ?

Compte tenu de l'art ascii et N, répétez cette Nfois.

• pour chaque personnage (nous l'appellerons ainsi A):
• laissez - Bêtre le caractère qui est exactement 1 à droite et 1 à partirA
• si Best un espace ou n'est pas défini:
• réglé Bsur A.

Spécifications

• La première entrée peut être une chaîne avec des caractères de nouvelle ligne ou une liste de chaînes représentant l'art ASCII 2D.
• Vous êtes autorisé à utiliser %END%pour marquer la fin de l'entrée, mais cela n'est pas obligatoire.
• La deuxième entrée sera N. Ce sera un entier positif.
• toutes les lignes des cordes auront la même longueur.

Exemples

Contribution: ("###\n###",1)

Production:

 ###
####
###

Règles

Les règles de base du code-golf s'appliquent.

aussi, si vous avez des questions, n'oubliez pas de demander dans les commentaires!

Perl, 81 octets

75 octets code + 6 pour -i -n0.
Notez que les \ecaractères sont ASCII \x1bmais \esont utilisés pour faciliter les tests.

Veuillez noter que cette solution utilise des séquences d'échappement ANSI et nécessite un terminal compatible, ainsi que l'utilisation de l' -iargument de ligne de commande pour transmettre le nombre de «dimensions» que vous souhaitez.

$n=s/^//mg-1;s/ /\e[1C/g;print(s/^/\e[${^I}C/grm."\e[${n}A"),--$^I for($_)x$^I

Usage:

Dans un terminal compatible Linux, exécutez d' PS1=abord pour vous assurer que votre invite ne remplace pas l'image affichée.

perl -i10 -n0e '$n=s/^//mg-1;s/ /\e[1C/g;print(s/^/\e[${^I}C/grm."\e[${n}A"),--$^I for($_)x$^I' <<< ' 
ROFL:ROFL:ROFL:ROFL
         _^___
 L    __/   [] \    
LOL===__        \ 
 L      \________]
         I   I
        --------/
'

          ROFL:ROFL:ROFL:ROFL
         ROFL:ROFL:ROFL:ROFL
        ROFL:ROFL:ROFL:ROFL
       ROFL:ROFL:ROFL:ROFL\
      ROFL:ROFL:ROFL:ROFL\_]
     ROFL:ROFL:ROFL:ROFL\_]
    ROFL:ROFL:ROFL:ROFL\_]/
   ROFL:ROFL:ROFL:ROFL\_]/
  ROFL:ROFL:ROFL:ROFL\_]/
 ROFL:ROFL:ROFL:ROFL\_]/
   LOL==___^___]_\_\_]/
  LOL==__/ \_[]_\_\_]/
 LOL===__ \______\_]/
  L      \________]/
          I---I---/
         --------/

perl -i3 -n0e '$n=s/^//mg-1;s/ /\e[1C/g;print(s/^/\e[${^I}C/grm."\e[${n}A"),--$^I for($_)x$^I' <<< 'X X DD
 X  D D
X X DD
'
   X X DD
  X X DD D
 X X DDDD
  X XDDD
 X X DD

CJam, 25 24 octets

{{' 1$f+La@+..{sS@er}}*}

Un bloc sans nom qui attend une liste de chaînes et le nombre de répétitions sur la pile et laisse une nouvelle liste de chaînes à la place.

Testez-le ici. (Comprend un wrapper de test qui lit la chaîne de STDIN pour plus de commodité.)

Explication

{       e# Repeat this block N times...
  '     e#   Push a space character.
  1$    e#   Copy the current grid.
  f+    e#   Prepend the space to each line of the grid.
  La    e#   Push [[]].
  @+    e#   Pull up the other copy of the grid and prepend the [].
        e#   We've now got two copies of the grid, one shifted right by
        e#   a cell and one shifted down by a cell. We now want to replace
        e#   spaces in the latter with the corresponding character in the
        e#   former.
  ..{   e#   For each pair of characters in corresponding positions...
    s   e#     Turn the character in the down-shifted grid into a string.
    S   e#     Push " ".
    @   e#     Pull up the character from the right-shifted grid.
    er  e#     Replace spaces with that character.
  }
}*

APL, 49 octets

{⎕UCS 32⌈{s+(s=0)×1⊖¯1⌽s←0⍪⍵,0}⍣⍺⊣(32∘≠×⊣)⎕UCS↑⍵}

Entrée: vecteur de vecteurs de caractères. Exemple:

      2 {⎕UCS 32⌈{s+(s=0)×1⊖¯1⌽s←0⍪⍵,0}⍣⍺⊣(32∘≠×⊣)⎕UCS↑⍵} 'X X DD' ' X  D D' 'X X DD'
  X X DD 
 X X DD D
X X DDDD 
 X XDDD  
X X DD   

Comment ça fonctionne:

• ↑⍵ transforme l'argument en une matrice de caractères
• ⎕UCS de char à entier
• (32∘≠×⊣) remplacer les espaces (32) par des zéros
• ...⍣⍺⊣ appliquer ⍺ (l'argument de gauche) fois la fonction de gauche
• s←0⍪⍵,0 frontière avec des zéros en haut et à droite l'argument
• 1⊖¯1⌽ faire pivoter 1 vers le haut et 1 vers la droite
• s+(s=0)× somme à l'original la version décalée mais uniquement au-dessus des zéros de l'original
• 32⌈ retourne les zéros en 32s
• ⎕UCS de l'entier au char

MATL , 24 octets

:"ct32>*TTYatFTEqYSy~*+c

Le format d'entrée est

2
{'X X DD', ' X  D D', 'X X DD'}

Donc, l'autre exemple est

1
{'###', '###'}

La sortie contient des espaces supplémentaires, ce qui est autorisé par le défi.

Essayez-le en ligne!

Si un tableau de caractères 2D est acceptable en entrée (j'ai demandé l'OP deux fois ...), le premier cpeut être supprimé, donc 23 octets :

:"t32>*TTYatFTEqYSy~*+c

Le format d'entrée dans ce cas est (toutes les chaînes ont des longueurs égales, ce qui peut nécessiter un remplissage à droite avec des espaces):

2
['X X DD '; ' X  D D'; 'X X DD ']

Essayez-le en ligne!

Explication

:        % Input number n implicitly. Generate [1 2 ... n]
"        % For loop: repeat n times
  c      %   Convert to char array. In the first iteration it inputs a cell array of
         %   strings implicitly and converts to a 2D char array, right-padding with
         %   spaces. In the next iterations it does nothing, as the top of the stack
         %   is already a 2D char array
  t32>*  %   Convert characters below 32 into 0
  TT     %   Push array [1 1]
  Ya     %   Pad the 2D char array with one zero in the two directions (up/down,
         %   left/right), on both sides
  t      %   Duplicate
  FTEq   %   Push array [-1 1]
  YS     %   Circularly shift the 2D char array one unit up and one unit right
  y      %   Push a copy of the non-shifted 2D array
  ~      %   Logical negate: nonzero entries become 0, zero entries become 1. This
         %   will be used as a mask for entries that need to be changed. Since the
         %   values at those entries are zero, we can simply add the new values. We do
         %   that by multiplying the mask by the shifted array and adding to the
         %   non-shifted array
  *      %   Multiply element-wise
  +      %   Add element-wise
  c      %   Convert the 2D array back to char
         % End for
         % Implicitly display

Convexe , 23 octets

Le nombre d'octets suppose le codage CP-1252.

{{' 1$f+La@+..{sS@Ë}}*}

Un bloc sans nom qui attend une liste de chaînes et le nombre de répétitions sur la pile et laisse une nouvelle liste de chaînes à la place.

Essayez-le en ligne!

Ceci est un port direct de ma réponse CJam à Convex (qui est fortement basé sur CJam). La seule différence est que Convex utilise Ëau lieu de erpour la translittération, économisant un octet. Merci à GamrCorps de m'avoir prévenu.

Pyth, 54 33 octets

ju+++dhG.bsmh|-d;;.t,Y+dNdtGGeG.*

Suite de tests.

JavaScript (ES6), 128 octets

f=(a,n)=>n?f((a=[``,...a].map(s=>[...s||` `])).map((b,i)=>i--&&b.map((c,j)=>a[i][++j]>' '?0:a[i][j]=c))&&a.map(b=>b.join``),n-1):a

Accepte et renvoie un tableau de chaînes, ajoute une ligne supplémentaire pour la sortie, garantit que chaque ligne contient au moins un espace, les divise toutes en caractères, boucle en essayant de copier les caractères sur la ligne ci-dessus et la colonne de droite, puis s'appelle récursivement pour terminer la boucle.

Python 2, 116 octets

S=' '
def f(a,d):e=[S*len(`a`)];exec"a=[''.join(t[t[1]>S]for t in zip(S+x,y+S))for x,y in zip(a+e,e+a)];"*d;return a

Je jouerai au golf plus bientôt.

Rubis, 95 octets

->a,n{n.downto(0){|i|f="<Esc>[1C"
$><<a.gsub(/^/,f*i).gsub(" ",f)+(i>0?"<Esc>[#{a.lines.size-1}A":"")}}

Chacun <Esc>est un caractère ESC littéral ( 0x1b).

Usage

Attribuez le lambda à une variable, par exemple func.

art = <<END
X X DD
 X  D D
X X DD
END

func[art, 2]
# Prints:
#   X X DD
#  X X DD D
# X X DDDD
#  X XDDD
# X X DD

Non golfé

->(art, num) {
  num.downto(0) do |i|
    forward = "\e[1C"
    $> << art.gsub(/^/, forward * i).gsub(" ", forward) +
            (i > 0 ? "\e[#{art.lines.size - 1}A" : "")
  end
}

La forwardséquence d'échappement \e[1C, déplace le curseur vers l'avant (à droite) d'un espace et le \e[<n>Adéplace vers le haut n. Fondamentalement, ce code fait imprimer les "couches" d'arrière en avant, en remplaçant les espaces par la forwardséquence pour éviter d'écraser les autres couches par un espace.