Khối lập phương đầu tiên được hoàn thành trước đó (PAC 1) là một khối lập phương đơn giản với chiều dài cạnh 1 và trông như thế này:

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

Các PAC 2 là một hình dạng hình học như vậy mà kết hợp nó với người tiền nhiệm của nó ( PAC 1 ) hoàn thành một chiều dài bên 2 khối:

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

Bởi vì back -view là loại nhàm chán, chúng tôi chỉ quan tâm đến việc xem trước .

Điều tương tự cũng xảy ra với PAC 3 : Với một số suy nghĩ trực quan, PAC 2 có thể được quay lại và cắm vào PAC 3 để tạo thành một khối 3 chiều dài vững chắc:

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

Và như vậy với PAC 4 :

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

Bài tập:

Viết chương trình hoặc hàm đầy đủ lấy số nguyên dương n làm đầu vào và trả về hoặc in giao diện trước tương ứng của PAC n chính xác như được hiển thị ở trên. Không gian trắng thêm vào là chấp nhận được.

Đây là môn đánh gôn , vì vậy hãy cố gắng sử dụng càng ít byte càng tốt trong ngôn ngữ bạn chọn.

JavaScript (ES6), 229 byte

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>

Mẻ, 559 432 400 byte

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

Giải thích: Nửa dưới của khối được vẽ bằng cách phản chiếu nửa trên. Các nửa được chia thành bảy sáu phần ba dải , theo sơ đồ này hiển thị nửa trên:

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. Độ lõm (làm giảm mọi hàng) và tam giác bên trái, làm tăng mọi hàng khác
2. Tam giác zigzag co lại ở giữa, với tam giác nhỏ ở hai bên xen kẽ mỗi hàng khác
3. Tam giác bên phải, tăng đồng bộ với bên trái

Chỉnh sửa: Đã lưu hơn 20% bằng cách cải thiện mã phản ánh từ trên xuống nửa dưới. Tiết kiệm gần 10% bằng cách hợp nhất hai dải bên trái và giữa.

Canvas , 36 byte

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

Hãy thử nó ở đây!

SOGL V0.12 , 32 byte

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

Hãy thử nó ở đây!

Giải thích đơn giản:
1. lặp lại cho mỗi 1..x
2. tạo một ⌐hình có chiều rộng i*4+1và chiều cao = (0-indexed)i // 2
3. đệm nó để trông giống như ⦧
4. nối hình "\" vào đó theo chiều ngang
5. chèn bước trước đó bên trong đó đảo ngược 6. sau tất cả mọi thứ, gương theo chiều dọc

chương trình đầy đủ:

ø                                 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

Haskell , 232 227 224 187 183 180 175 byte

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

Hàm ẩn danh trong dòng cuối cùng lấy một đối số nguyên và mang lại các dòng được in cho một khối có kích thước đó.

Ý tưởng là sử dụng đệ quy để vẽ các hình khối lớn hơn từ những cái nhỏ hơn. Hãy nhìn vào nửa trên của một khối có kích thước 1. Sau đó, chúng ta có được nửa trên của một khối có kích thước 2 bằng cách phản chiếu nửa trước và thêm một mẫu dấu gạch chéo và khoảng trắng cố định xung quanh nó:

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

Vậy thuật toán vẽ hình lập phương có kích thước n là

1. Lấy các đường cho nửa khối trên có kích thước n-1 .
2. Phản chiếu từng dòng (bằng cách lật /s và \s), và pad ////và \xung quanh.
3. Chuẩn bị hai dòng với mẫu ////ⁿ cộng /\và / \.
4. Phản chiếu các dòng kết quả để có được khối lập phương đầy đủ.
5. Dòng pad với số lượng không gian thích hợp.

Ruby , 174 167 169 167 byte

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

Hãy thử trực tuyến!

tạo ra một n*4chuỗi các chuỗi chứa đầy khoảng trắng, sau đó ghi đè lên nó bằng các hình khối nhỏ hơn liên tiếp.

Mã nhận xét

->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 $/

Python 2 , 254 234 226 203 201 199 byte

Cuối cùng phụ 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])))

Thủ thuật:

Hàm này được sử dụng để trao đổi tất cả \với /và ngược lại
Một chút dài trong Python2 - chỉ hoạt động với unicode
Kiểm tra điều này để biết cách hoạt động của nó

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

Tạo hai hàng đầu mới cho mỗi lần lặp
Hiện tại tôi không thể tìm thấy cách nhỏ gọn để nhận dòng này từ lần lặp trước

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

Đảo ngược tất cả các hàng của lần lặp trước và dấu gạch chéo

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

Sao chép nửa trên, đảo ngược bởi các hàng, hoán đổi dấu gạch chéo

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

Phương pháp gọn gàng cho chuỗi đệm trung tâm

l.center(8*n)

Hãy thử trực tuyến!

Stax , 36 byte

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

Chạy và gỡ lỗi nó

Cách tiếp cận này xây dựng nửa đầu của đầu ra lặp đi lặp lại. Nó thực thi khối chính số lần chỉ định. Trong khối đó, mỗi hàng được nhân đôi và có thêm tiền tố và hậu tố. Hai hàng mới trên cùng được thêm vào riêng biệt. Khi tất cả các hàng được xây dựng, chúng được căn giữa và sau đó phần dưới được nhân đôi theo chiều dọc.

Đây là chương trình giải nén, không ghi chú và nhận xét.

{               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

Chạy cái này

Haskell, 193 byte

Dài hơn người chiến thắng, nhưng cách tiếp cận có thể thú vị - sử dụng chẵn cosvà pi:)

Mã số:

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

Chạy nó như thế này:

mapM_ putStrLn (f 4)

Chương trình này về cơ bản 'vẽ' nhiều viên kim cương như thế này:

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

Chức năng i s e f'lôi kéo' một viên kim cương kích thước s, nơi e, fđược (abs$z-y)(abs$z+y-1).

Chức năng wdi chuyển các viên kim cương được vẽ bởi các i vị trí chính xác. headđược sử dụng trong định nghĩa của nó có trách nhiệm chỉ nhìn vào lớp trên cùng.

Hãy thử nó ở đây

Than , 42 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

ＦＮ«

Vẽ các hình khối từ nhỏ nhất đến lớn nhất. (Vẽ từ lớn nhất đến nhỏ nhất có nghĩa là tôi đã kết thúc bằng một hình ảnh phản chiếu cho các số lẻ có giá quá nhiều byte để sửa.)

↗×⊗⊕ι/

In một dòng /s. (Điều này sẽ trở thành \s ở bên phải, nhưng bản vẽ được thực hiện nhân đôi vì nó sẽ phản chiếu ở cuối vòng lặp.)

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

In hai hàng trên cùng của \s. (Vẽ tất cả các \s trong một đa giác có nghĩa là con trỏ kết thúc ở một vị trí khó xử, tốn quá nhiều byte để sửa.)

Ｇ←⁴↘⊕⊗ι→⁴\

In bốn hàng bên trái của \s. (Hàng thứ năm đến từ khối trước.)

Ｍ⁴→

Di chuyển đến điểm bắt đầu của khối tiếp theo.

‖Ｔ»

Phản ánh theo chiều ngang đã sẵn sàng cho khối tiếp theo.

‖Ｍ↓

Phản chiếu mọi thứ theo chiều dọc để hoàn thành khối lập phương.