Bei dieser Herausforderung müssen Sie ASCII-Grafiken (normalerweise 2D) in 3D bringen!

Wie?

so was,

X X DD 
 X  D D
X X DD 

zu...

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

Wie machen wir das dann ?

NWiederholen Sie diese NZeiten angesichts der ASCII-Kunst und .

• für jeden Charakter (wir werden das nennen A):
• Sei Bdas Zeichen, das genau 1 richtig und 1 höher istA
• Wenn Bes sich um ein Leerzeichen handelt oder undefiniert ist:
• gesetzt Bzu A.

Technische Daten

• Die erste Eingabe kann eine Zeichenfolge mit Zeilenumbrüchen oder eine Liste von Zeichenfolgen sein, die die 2D-ASCII-Grafik darstellen.
• Sie dürfen %END%das Ende der Eingabe markieren, dies ist jedoch nicht erforderlich.
• Der zweite Eingang wird sein N. Es wird eine positive ganze Zahl sein.
• Alle Zeilen der Zeichenfolgen sind gleich lang.

Beispiele

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

Ausgabe:

 ###
####
###

Regeln

Es gelten grundlegende Code-Golf- Regeln.

Wenn Sie Fragen haben, stellen Sie diese bitte in den Kommentaren!

Perl, 81 Bytes

75 Bytes Code + 6 für -i -n0.
Beachten Sie, dass die \eZeichen ASCII-Zeichen sind, \x1baber \ezum leichteren Testen verwendet werden.

Beachten Sie, dass diese Lösung ANSI-Escape-Sequenzen verwendet und ein kompatibles Terminal erfordert sowie das -iBefehlszeilenargument verwendet, um die Anzahl der gewünschten 'Dimensionen' zu übergeben.

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

Verwendung:

Führen Sie in einem Linux-kompatiblen Terminal PS1=zuerst aus, um sicherzustellen, dass Ihre Eingabeaufforderung das angezeigte Bild nicht überschreibt.

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}}*}

Ein unbenannter Block, der eine Liste von Zeichenfolgen und die Anzahl der Wiederholungen auf dem Stapel erwartet und stattdessen eine neue Liste von Zeichenfolgen hinterlässt.

Testen Sie es hier. (Enthält einen Test-Wrapper, der die Zeichenfolge der Einfachheit halber aus STDIN liest.)

Erläuterung

{       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↑⍵}

Eingabe: Vektor der Zeichenvektoren. Beispiel:

      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   

Wie es funktioniert:

• ↑⍵ verwandelt das Argument in eine Matrix von Zeichen
• ⎕UCS von char bis integer
• (32∘≠×⊣) Ersetzen Sie die Leerzeichen (32) durch Nullen
• ...⍣⍺⊣ wende ⍺ (das linke Argument) mal die Funktion auf der linken Seite an
• s←0⍪⍵,0 Rand mit Nullen oben und rechts das Argument
• 1⊖¯1⌽ 1 nach oben und 1 nach rechts drehen
• s+(s=0)× Summe der verschobenen Version zum Original, jedoch nur über den Nullen des Originals
• 32⌈ verwandelt die Nullen in 32s zurück
• ⎕UCS von Integer zu Char

MATL , 24 Bytes

:"ct32>*TTYatFTEqYSy~*+c

Eingabeformat ist

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

Das andere Beispiel ist also

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

Die Ausgabe enthält zusätzliche Leerzeichen, die von der Herausforderung zugelassen werden.

Probieren Sie es online aus!

Wenn ein 2D-Zeichenarray als Eingabe akzeptabel ist (ich habe das OP zweimal gefragt ...), kann das erste centfernt werden, also 23 Bytes :

:"t32>*TTYatFTEqYSy~*+c

Das Eingabeformat ist in diesem Fall (alle Zeichenfolgen sind gleich lang, was möglicherweise ein Auffüllen mit Leerzeichen erfordert):

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

Probieren Sie es online aus!

Erläuterung

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

Konvex , 23 Bytes

Die Byteanzahl setzt eine CP-1252-Codierung voraus.

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

Ein unbenannter Block, der eine Liste von Zeichenfolgen und die Anzahl der Wiederholungen auf dem Stapel erwartet und stattdessen eine neue Liste von Zeichenfolgen hinterlässt.

Probieren Sie es online aus!

Dies ist ein direkter Port meiner CJam-Antwort auf Convex (die stark auf CJam basiert). Der einzige Unterschied besteht darin, dass Convex Ëanstelle der erTransliteration ein Byte spart. Vielen Dank an GamrCorps, dass Sie mich darüber informiert haben.

Pyth, 54 33 Bytes

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

Testsuite.

JavaScript (ES6), 128 Byte

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

Akzeptiert ein Array von Zeichenfolgen und gibt es zurück, stellt eine zusätzliche Zeile für die Ausgabe voran, stellt sicher, dass jede Zeile mindestens ein Leerzeichen enthält, teilt sie alle in Zeichen auf, führt Schleifen durch, obwohl versucht wird, die Zeichen in die Zeile oben und die Spalte rechts zu kopieren ruft sich rekursiv auf, um die Schleife zu vervollständigen.

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

Ich werde das bald mehr Golf spielen.

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":"")}}

Jedes <Esc>ist ein wörtliches ESC-Zeichen ( 0x1b).

Verwendung

Ordnen Sie das Lambda einer Variablen zu, z 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

Ungolfed

->(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
}

Die forwardEscape-Sequenz \e[1Cbewegt den Cursor 1 Feld vorwärts (rechts) und \e[<n>Abewegt ihn nach oben n. Grundsätzlich druckt dieser Code die "Ebenen" von hinten nach vorne und ersetzt Leerzeichen durch die forwardSequenz, um zu vermeiden, dass die anderen Ebenen durch ein Leerzeichen überschrieben werden.