첫 번째 선행 작업 완료 Ascii 큐브 (PAC 1) 는 측면 길이가 1 인 간단한 큐브이며 다음과 같습니다.

 /////\
/////  \
\\\\\  /
 \\\\\/

PAC 2 전신 (과 결합되도록 기하학적 형상 인 PAC 것은 1 ) 측면 길이 2 큐브 완료 :

      front                back
   /////////\           /////////\
  /////////  \         /////////  \
 /////\\\\\   \       /////////    \
/////  \\\\\   \     /////////      \
\\\\\  /////   /     \\\\\\\\\      /
 \\\\\/////   /       \\\\\\\\\    /
  \\\\\\\\\  /         \\\\\\\\\  /
   \\\\\\\\\/           \\\\\\\\\/

때문에 백 -보기 종류 지루하다, 우리는 단지에 관심이 앞 -보기.

PAC 3 의 경우도 마찬가지입니다 . 시각적으로 생각하면 PAC 2 를 뒤집어 PAC 3 에 꽂아 솔리드 사이드 길이 3 큐브를 만들 수 있습니다.

     /////////////\
    /////////////  \
   /////\\\\\\\\\   \
  /////  \\\\\\\\\   \
 /////   /////\\\\\   \
/////   /////  \\\\\   \
\\\\\   \\\\\  /////   /
 \\\\\   \\\\\/////   /
  \\\\\  /////////   /
   \\\\\/////////   /
    \\\\\\\\\\\\\  /
     \\\\\\\\\\\\\/

그리고 PAC 4 와 마찬가지로 :

       /////////////////\
      /////////////////  \
     /////\\\\\\\\\\\\\   \
    /////  \\\\\\\\\\\\\   \
   /////   /////////\\\\\   \
  /////   /////////  \\\\\   \
 /////   /////\\\\\   \\\\\   \
/////   /////  \\\\\   \\\\\   \
\\\\\   \\\\\  /////   /////   /
 \\\\\   \\\\\/////   /////   / 
  \\\\\   \\\\\\\\\  /////   /
   \\\\\   \\\\\\\\\/////   /
    \\\\\  /////////////   /
     \\\\\/////////////   /
      \\\\\\\\\\\\\\\\\  /
       \\\\\\\\\\\\\\\\\/

태스크:

양의 정수 n을 입력으로 사용하고 위에 표시된대로 PAC n 의 해당 전면보기를 반환하거나 인쇄하는 전체 프로그램 또는 함수를 작성하십시오 . 추가 후행 공백이 허용됩니다.

이것은 code-golf 이므로 원하는 언어로 가능한 적은 바이트를 사용하십시오.

자바 스크립트 (ES6), 229 바이트

f=
(n,l=n*4+1,r=1,i=n*2,g=a=>` / \\ /
`.replace(/./g,c=>c.repeat(a.pop())))=>n?g([r,,l,--i])+g([r,2,l,--i])+f(n-1,l-1?1:r-4,r-1?1:l-4).replace(/(\S).*(.)/g,r-1?`$1   $&$2$2$2$2`:`$1$1$1$1$&   $2`)+g([r,2,l,,,i])+g([r,,l,,,i+1]):``

<input type=number min=0 oninput=o.textContent=f(+this.value)><pre id=o>

배치, 559 432 400 바이트

@echo off
set m=
for /l %%i in (1,1,%1)do call set m=  %%m%%
call:c "%m:~2%" %m: =//%/\
exit/b
:c
setlocal
set m=%~1%2%~3
echo  %m%
echo %m:/\=/  \%
set s=%~1
if "%s:~,1%"=="/" goto g
set t=%2
set t=%t:~3,-3%
if %t:~,1%==/ (call:c "%s:~2%////" /\%t:/=\% "   \%~3")else call:c "%s:~2%/   " %t:\=/%/\ "\\\\%~3"
:g
set m=%m:/=-%
set m=%m:\=/%
set m=%m:-=\%
echo %m:\/=\  /%
echo  %m%

설명 : 큐브의 아래쪽 절반이 위쪽 절반을 반영하여 그려집니다. 이 그림에 따라 절반은 7 개의 6 개의 3 개의 스트립으로 나뉩니다.

1       12/////////////////\233
1      12/////////////////  \233
1     ////12/\\\\\\\\\\\\\23   \3
1    ////12/  \\\\\\\\\\\\\23   \3
1   /////   12/////////\23\\\\   \3
1  /////   12/////////  \23\\\\   \3
1 /////   ////12/\\\\\23   \\\\\   \3
1/////   ////12/  \\\\\23   \\\\\   \3

1. 들여 쓰기 (모든 행을 줄임) 및 왼쪽 삼각형 (다른 행을 늘림)
2. 중간 수축 지그재그 삼각형, 작은 삼각형이 다른 행마다 번갈아 가며 나타남
3. 오른쪽 삼각형은 왼쪽과 동기화되면서 증가합니다

편집 : 위쪽과 아래쪽 절반을 반영하는 코드를 개선하여 20 % 이상 절약했습니다. 왼쪽 2 개와 중간 3 개 스트립을 병합하여 거의 10 %를 절약했습니다.

캔버스 , 36 바이트

；Ｘø；｛１ｘ／╋
ø╶｛«５⁸２²４×⁸²«１╋²«＼＋；↔５３╋｝═

여기 사용해보십시오!

SOGL V0.12 , 32 바이트

ø.∫4*I└*2∙f«5└*∙+¼F«╝┼;↔±53╬5}╬±

여기 사용해보십시오!

간단한 설명 :
1..x 각각에 대하여 반복 1.
2.는 확인 ⌐의 폭과 모양 i*4+1및 높이 = (0-indexed)i // 2
이 보이는 것이되도록 패드 3. ⦧
4. APPEND A를 "\"모양이 가로로
5 이전 단계 삽입 내부는 모든 것을 뒤집었다.

전체 프로그램 :

ø                                 push an empty string - starting stage
 .∫                          }    iterate over 1..input
   4*                               multiply the 1-indexed counter by 4
     I                              and add 1
      └*                            repeat "/" that many times
        2∙                          and repeat vertically twice. Top 2 lines are done
          f«                        push the 0-indexed counter floor divided by 2
            5└*                     push "/" repeated 5 times
               ∙                    and repeat that vertically by the result of the "f«"
                +                   add vertically, creating a "⌐" shape
                 ¼                  prepend each next line with one less space than the above
                  F«                push 1-indexed counter floor divided by 2
                    ╝               create a "\" diagonal that long
                     ┼              and append it horizontally. Shell is done of this hexagon
                      ;↔±           get the previous item on the stack and reverse it horizontally
                         53╬5       and at [5;3] insert the previous result in this
                              ╬±  once everything's done, mirror vertically to finish the hexagon

하스켈 , 232 227 224 187 183 180 175 바이트

m '/'='\\'
m '\\'='/'
m c=c
r=reverse
k=map
n?s=('/'<$[1..4*n])++s
f 0=[]
f n=n?"/\\":n?"/  \\":[1?k m(r s)++"   \\"|s<-f$n-1]
s="":k(' ':)s
((++).r<*>k(k m)).zipWith(++)s.r.f

마지막 행의 익명 함수는 정수 인수를 사용하여 해당 크기의 큐브에 대해 인쇄 될 행을 생성합니다.

아이디어는 재귀를 사용하여 작은 큐브에서 큰 큐브를 그리는 것입니다. 크기가 1 인 큐브의 위쪽 절반을 살펴 보겠습니다. 그런 다음 이전 절반을 미러링하여 크기가 2 인 큐브의 위쪽 절반을 가져오고 그 주위에 고정 된 슬래시와 공백 패턴을 추가합니다.

                                         ///////// \
                                        ///////// \
     ///// \ ==> / \\\\\ ==> //// / \\\\\    \
    ///// \ / \\\\\ //// / \\\\\    \

크기 n 의 큐브를 그리는 알고리즘 은

1. 크기 n-1 의 상단 큐브 절반에 대한 선을 가져옵니다 .
2. /s와 \s 를 뒤집어서 각 선을 대칭 시키고 패드 ////를 \돌립니다.
3. 패턴 ////ⁿ 더하기 /\및로 두 줄을 앞에 추가하십시오 / \.
4. 결과 라인을 미러링하여 전체 큐브를 얻습니다.
5. 적절한 수의 공백이있는 줄을 채우십시오.

루비 , 174 167 169 167 바이트

->n{a=(1..m=n*4).map{' '*m}
(-n..0).map{|i|(-2*i).times{|k|a[y=k+2*j=n+i][m+~k+i*2,2+k*2-s=4*i]=?/*(1-~j%2*s)+'  '*k+?\\*(1-j%2*s)
a[~y]=a[y].tr('/\\','\\\\/')}}
a*$/}

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

n*4공백으로 채워진 문자열 배열을 만든 다음 연속적으로 작은 큐브로 덮어 씁니다.

주석이 달린 코드

->n{a=(1..m=n*4).map{' '*m}                 #make an array of n*4 strings of n*4 spaces (up to centreline of final output)
  (-n..0).map{|i|                           #iterate through cube sizes from n down to 0 (i is negative -n to 0)
    (-2*i).times{|k|                        #iterate through the number of lines in the top half of the cube
      a[y=k+2*j=n+i][m+~k+i*2,2+k*2-s=4*i]= #overwrite the correct part of the correct line
      ?/*(1-~j%2*s)+'  '*k+?\\*(1-j%2*s)    #with the correct string of the form "/spaces\" with an additional -4*i symbols on one side
      a[~y]=a[y].tr('/\\','\\\\/')          #copy the current line from top half into bottom half, subsituting / for \ and vice versa
    }
  }
a*$/}                                       #return the elements of the array a, concatenated with newlines $/

파이썬 (2) , 254 (234) 226 203 201 199 바이트

마지막으로 서브 200!

P=[];n=0
M=lambda r:(u''+r).translate({47:92,92:47})
exec r"n+=1;q='/'*4;P=[q*n+'/\\',q*n+'/  \\']+[q+'%s   \\'%M(r[::-1])for r in P];"*input()
print'\n'.join(l.center(8*n)for l in(P+map(M,P[::-1])))

트릭 :

이 기능은 모든 스왑하는 데 사용됩니다 \와 /그 반대의
A는 Python2 긴 비트 - 유니 코드에서만 작동
확인 이 어떻게 작동하는지에 대한

M=lambda r:(u''+r).translate({47:92,92:47})

각 반복마다 새로운 두 개의 행을 생성합니다.
지금은 이전 반복 에서이 줄을 수신하는 간단한 방법을 찾을 수 없습니다.

P=[q*n+'/\\',q*n+'/  \\']

이전 반복의 모든 행을 뒤집고 슬래시를 바꿉니다.

[q+'%s   \\'%M(r[::-1])for r in P]

상반신 복사, 행 반전, 슬래시 교체

P+map(M,P[::-1])

가운데 패딩 문자열을위한 깔끔한 방법

l.center(8*n)

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

Stax , 36 바이트

äª.$u>↓Z╙╝B↨EXª¡╜?Xáhç∙╩p/♂ù⌠r↨c⌐f/*

실행 및 디버깅

이 접근법은 반복적으로 출력의 상위 절반을 구성합니다. 메인 블록을 지정된 횟수만큼 실행합니다. 이 블록에서 각 행은 미러링되며 접두사와 접미사가 추가됩니다. 맨 위 두 개의 새 행이 별도로 추가됩니다. 모든 행이 작성되면 중앙에 놓인 다음 맨 아래가 세로로 대칭됩니다.

다음은 압축을 풀고 포장을 풀고 주석이 달린 프로그램입니다.

{               begin block to repeat
  iHYH^H'\*     make a string of '\' characters and set the Y register
                  pseudo-code: push(((y = (i * 2)) * 2 + 1) * 2 * '\')
                  given the 0-based iteration index `i`, let y = 2 * i
                  and push a string consisting of (i*8 + 2) backslashes
  2M            split the string into to equal size (i*4 + 1) substrings
  ~+            push array to input stack and concatenate
                  on the first iteration, this is a no-op
                  subsequently, it prepends the array to the result so far
  {             begin a block to use for mapping
    4'\*+       append 4 backslashes to this element
    :R          "brace-wise" reverse
                  this reverses the string AND the slashes in it
    |YH3+92&    write 92 to index (++y * 2 + 3) in the array
                  this puts the trailing backslash at the correct position
                  this will be an out of bounds index, so the string will grow
                  92 is the character code for backslash 
  m             execute map using block
}*              repeat block specified number of times
|C              vertically center all rows
{               begin block for output mapping
  Q             output this line without popping
  :Rr           "brace-wise" reverse, and then actually reverse
                  net effect is to swap forward and backward slashes
m               execute map using block
rm              reverse array, and output all rows

이것을 실행

하스켈, 193 바이트

승자보다 길지만 접근 방식이 흥미로울 수 있습니다-짝수 cos및 pi:)

암호:

i s e f|max e f>s=""|max e f<s=" "|e==s="\\"|1<2="/"
w n y x=head$do{d<-[1..n];o<-[-2*d..2*d];z<-[(cos(pi*(n-d)))*o+x];i(2*d)(abs$z-y)(abs$z+y-1)}++" "
n!h=h<$>[1-2*n..2*n]
f n=((2*n)!)<$>n!w n

다음과 같이 실행하십시오.

mapM_ putStrLn (f 4)

이 프로그램은 기본적으로 다음과 같은 많은 다이아몬드를 '그립니다'.

------------------------
------------------------
-----------/\-----------
----------/  \----------
---------/    \---------
--------/      \--------
--------\      /--------
---------\    /---------
----------\  /----------
-----------\/-----------
------------------------
------------------------

기능 i s e f크기의 하나 개의 다이아몬드 '무' s, e, f됩니다 (abs$z-y)(abs$z+y-1).

기능 w은 그려진 다이아몬드 i 를 올바른 위치로 이동시킵니다 . head정의에 사용 된 것은 최상위 레이어 만 볼 책임이 있습니다.

여기 사용해보십시오

숯 , 42 바이트

ＦＮ«↗×⊗⊕ι/↓↘Ｇ↖²→⊕×⁴⊕ι↘²\Ｇ←⁴↘⊕⊗ι→⁴\Ｍ⁴→‖Ｔ»‖Ｍ↓

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

ＦＮ«

가장 작은 것에서 가장 큰 것까지 큐브를 그립니다. (가장 큰 것에서 가장 작은 것으로 그림은 너무 많은 바이트를 수정하는 홀수에 대한 거울 이미지로 끝났다는 것을 의미했습니다.)

↗×⊗⊕ι/

/s 줄을 인쇄하십시오 . (이것은 \오른쪽 의 s 가 되지만, 루프 끝에서 골퍼가되기 때문에 그림이 미러링됩니다.)

↓↘Ｇ↖²→⊕×⁴⊕ι↘²\

\s 의 맨 위 두 행을 인쇄하십시오 . (모든 \다각형을 하나의 다각형으로 그리면 커서가 어색한 위치에있게되어 수정하기에는 너무 많은 바이트가 필요했습니다.)

Ｇ←⁴↘⊕⊗ι→⁴\

\s 의 왼쪽 네 행을 인쇄하십시오 . 다섯 번째 행은 이전 큐브에서 나옵니다.

Ｍ⁴→

다음 큐브의 시작으로 이동하십시오.

‖Ｔ»

다음 큐브에 수평으로 준비하십시오.

‖Ｍ↓

큐브를 완성하기 위해 모든 것을 수직으로 미러링합니다.