이 도전에서는 ASCII 아트 (보통 2D)를 3D로 가져와야합니다!

어떻게?

이렇게

X X DD 
 X  D D
X X DD 

에...

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

그럼 어떻게 우리가 할 것을 ?

아스키 아트와을 고려하여 이번에도 N반복하십시오 N.

• 모든 캐릭터에 대해 (우리는 이것을 호출 할 것입니다 A) :
• B정확히 1에서 1까지의 문자를 보자.A
• 경우는 B공백 또는 정의되지 않는다 :
• 로 설정 B하십시오 A.

명세서

• 첫 번째 입력은 개행 문자가 포함 된 문자열이거나 2D ASCII 아트를 나타내는 문자열 목록 일 수 있습니다.
• %END%입력 끝을 태그하는 데 사용할 수 있지만 필수는 아닙니다.
• 두 번째 입력은 N . 양의 정수가됩니다.
• 줄의 모든 줄의 길이는 같습니다.

예

입력: ("###\n###",1)

산출:

 ###
####
###

규칙

기본 코드 골프 규칙이 적용됩니다.

또한 궁금한 점이 있으면 의견을 보내주십시오!

펄, 81 바이트

75 바이트 코드 + 6 -i -n0.
참고 것을 \e문자가 ASCII입니다 \x1b만\e 테스트의 용이성을 위해 사용된다.

이 솔루션은 ANSI 이스케이프 시퀀스를 사용하며 호환 가능한 터미널과 -i명령 행 인수를 사용하여 원하는 '치수'수를 전달해야합니다.

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

용법:

Linux 호환 터미널에서 PS1=프롬프트가 표시된 이미지를 덮어 쓰지 않도록 먼저 실행 하십시오.

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 바이트

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

문자열 목록과 스택의 반복 횟수를 예상하고 대신 새 문자열 목록을 남기는 명명되지 않은 블록입니다.

여기에서 테스트하십시오.편의상 STDIN에서 문자열을 읽는 테스트 랩퍼를 포함합니다.

설명

{       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 바이트

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

입력 : 문자형 벡터로 구성된 벡터입니다. 예:

      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   

작동 방식 :

• ↑⍵ 인수를 문자 행렬로 변환
• ⎕UCS 문자에서 정수로
• (32∘≠×⊣) 공백 (32)을 0으로 바꾸십시오
• ...⍣⍺⊣ 왼쪽의 함수에 ⍺ (왼쪽 인수) 곱하기
• s←0⍪⍵,0 인수의 상단과 오른쪽에 0이있는 경계
• 1⊖¯1⌽ 1을 오른쪽으로 1 회전
• s+(s=0)× 원래 버전의 이동 된 버전과 합하지만 원래 0의 맨 위에 만
• 32⌈ 0을 32로 되돌립니다.
• ⎕UCS 정수에서 문자까지

MATL , 24 바이트

:"ct32>*TTYatFTEqYSy~*+c

입력 형식은

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

다른 예는

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

출력에 추가 공백이 포함되어 있으며이 공백은 챌린지에 의해 허용됩니다.

온라인으로 사용해보십시오!

2D char 배열이 입력으로 허용 가능한 경우 (OP에 두 번 요청했습니다 ...) 첫 번째 바이트를c 제거 할 수 있으므로 23 바이트 :

:"t32>*TTYatFTEqYSy~*+c

이 경우 입력 형식은 다음과 같습니다 (모든 문자열의 길이가 동일하므로 공백이있는 오른쪽 여백이 필요할 수 있음).

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

온라인으로 사용해보십시오!

설명

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

볼록 , 23 바이트

바이트 수는 CP-1252 인코딩을 가정합니다.

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

문자열 목록과 스택의 반복 횟수를 예상하고 대신 새 문자열 목록을 남기는 명명되지 않은 블록입니다.

온라인으로 사용해보십시오!

이것은 CJam에 대한 Convex (CJam에 크게 기반)에 대한 직접적인 포트입니다 . 유일한 차이점은 음역 Ë대신 Convex가 사용 er하여 1 바이트를 절약 한다는 것입니다 . 알려 주신 GamrCorps에게 감사드립니다.

Pyth, 54 33 바이트

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

테스트 스위트.

JavaScript (ES6), 128 바이트

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

문자열 배열을 수락하고 반환하고 출력에 추가 행을 추가하고 각 행에 최소한 공백이 있는지 확인하고 모두 공백으로 문자를 분할하고 문자를 위의 행과 열의 오른쪽에 복사하려고 시도하지만 루프합니다. 루프를 완료하기 위해 재귀 적으로 호출합니다.

파이썬 2, 116 바이트

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

더 빨리 골프하겠습니다.

루비, 95 바이트

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

각각 <Esc>은 문자 그대로의 ESC 문자 ( 0x1b)입니다.

용법

람다를 변수에 할당하십시오 (예 :) 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

언 골프

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

forward이스케이프 시퀀스는 \e[1C앞으로 커서 (오른쪽) 한 공간 이동과 \e[<n>A이동을 닫 n라인. 기본적으로이 코드는 "레이어"를 앞뒤로 인쇄 forward하여 다른 레이어를 공백으로 덮어 쓰지 않도록 공백을 시퀀스로 바꿉니다 .