En este desafío, ¡tienes que llevar el arte ASCII (que generalmente es 2D) a 3D!

¿Cómo?

Me gusta esto,

X X DD 
 X  D D
X X DD 

a...

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

Entonces, ¿cómo hacemos eso ?

Dado el arte ascii y N, repito esta Nvez.

• para cada personaje (lo llamaremos A):
• dejar Bser el personaje que es exactamente 1 correcto y 1 arriba deA
• si Bes un espacio o no está definido:
• establecer Ba A.

Especificaciones

• La primera entrada puede ser una cadena con caracteres de nueva línea o una lista de cadenas que representan el arte 2D ASCII.
• Puede usarlo %END%para etiquetar el final de la entrada, pero esto no es obligatorio.
• La segunda entrada será N. Será un número entero positivo.
• Todas las líneas de las cadenas tendrán la misma longitud.

Ejemplos

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

Salida:

 ###
####
###

Reglas

Se aplican reglas básicas de código de golf .

Además, si tiene preguntas, asegúrese de preguntar en los comentarios.

Perl, 81 bytes

Código de 75 bytes + 6 para -i -n0.
Tenga en cuenta que los \ecaracteres son ASCII \x1bpero \ese utilizan para facilitar la prueba.

Tenga en cuenta que esta solución utiliza secuencias de escape ANSI y requiere un terminal compatible, además de utilizar el -iargumento de la línea de comandos para pasar el número de 'dimensiones' que desea.

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

Uso:

En un terminal compatible con Linux, ejecute PS1=primero para asegurarse de que su solicitud no sobrescriba la imagen mostrada.

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 bytes

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

Un bloque sin nombre que espera una lista de cadenas y el número de repeticiones en la pila y deja una nueva lista de cadenas en su lugar.

Pruébalo aquí. (Incluye un contenedor de prueba que lee la cadena de STDIN para mayor comodidad).

Explicación

{       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 bytes

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

Entrada: vector de vectores de caracteres. Ejemplo:

      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   

Cómo funciona:

• ↑⍵ convierte el argumento en una matriz de caracteres
• ⎕UCS de char a entero
• (32∘≠×⊣) sustituir los espacios (32) con ceros
• ...⍣⍺⊣ aplicar ⍺ (el argumento izquierdo) multiplicado por la función de la izquierda
• s←0⍪⍵,0 borde con ceros arriba y a la derecha el argumento
• 1⊖¯1⌽ gire 1 hacia arriba y 1 hacia la derecha
• s+(s=0)× suma al original la versión desplazada pero solo encima de los ceros del original
• 32⌈ convierte los ceros en 32s
• ⎕UCS de entero a char

MATL , 24 bytes

:"ct32>*TTYatFTEqYSy~*+c

El formato de entrada es

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

Entonces el otro ejemplo es

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

La salida contiene espacios en blanco adicionales, lo que está permitido por el desafío.

Pruébalo en línea!

Si una matriz de caracteres 2D es aceptable como entrada (le he pedido al OP dos veces ...), la primera cse puede eliminar, por lo que 23 bytes :

:"t32>*TTYatFTEqYSy~*+c

El formato de entrada en este caso es (todas las cadenas tienen la misma longitud, lo que puede requerir el relleno derecho con espacios):

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

Pruébalo en línea!

Explicación

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

Convexo , 23 bytes

El recuento de bytes supone la codificación CP-1252.

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

Un bloque sin nombre que espera una lista de cadenas y el número de repeticiones en la pila y deja una nueva lista de cadenas en su lugar.

Pruébalo en línea!

Este es un puerto directo de mi respuesta de CJam a Convex (que se basa en gran medida en CJam). La única diferencia es que Convex usa en Ëlugar de ertransliteración, ahorrando un byte. Gracias a GamrCorps por informarme al respecto.

Pyth, 54 33 bytes

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

Banco de pruebas.

JavaScript (ES6), 128 bytes

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

Acepta y devuelve una serie de cadenas, antepone una fila adicional para la salida, asegura que cada fila contenga al menos un espacio, las divide en caracteres, realiza un bucle aunque intenta copiar los caracteres en la fila superior y la columna a la derecha, luego recursivamente se llama a sí mismo para completar el ciclo.

Python 2, 116 bytes

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

Voy a jugar al golf más pronto.

Ruby, 95 bytes

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

Cada uno <Esc>es un carácter ESC literal ( 0x1b).

Uso

Asigne el lambda a una variable, por ejemplo 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

Sin 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 forwardsecuencia de escape \e[1C, mueve el cursor hacia adelante (derecha) 1 espacio y \e[<n>Asube las nlíneas. Básicamente, lo que hace este código es imprimir las "capas" de atrás hacia adelante, reemplazando espacios con la forwardsecuencia para evitar sobrescribir las otras capas con un espacio.