Asciior ที่สร้างเสร็จสมบูรณ์ก่อนหน้า (PAC 1) รุ่นแรกคือคิวบ์แบบง่ายที่มีความยาวด้าน 1 และมีลักษณะดังนี้:

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

PAC 2เป็นรูปทรงเรขาคณิตเช่นว่ารวมกับบรรพบุรุษของมัน (คน PAC 1 ) เสร็จสมบูรณ์ความยาวด้านข้าง 2 ก้อน:

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

เนื่องจากมุมมองด้านหลังนั้นค่อนข้างน่าเบื่อเราจึงสนใจเฉพาะมุมมองด้านหน้าเท่านั้น

เช่นเดียวกันสำหรับPAC 3 : ด้วยความคิดที่มองเห็นPAC 2สามารถหมุนไปรอบ ๆ และเสียบเข้ากับPAC 3เพื่อสร้างความยาวด้านที่เป็นของแข็ง 3 ลูกบาศก์:

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

และอื่น ๆ ด้วยPAC 4 :

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

งาน:

เขียนโปรแกรมหรือฟังก์ชั่นเต็มรูปแบบซึ่งรับจำนวนเต็มบวก n เป็นอินพุตและส่งคืนหรือพิมพ์มุมมองด้านหน้าที่สอดคล้องกันของPAC nตรงตามที่แสดงด้านบน ยอมรับพื้นที่สีขาวเพิ่มเติมได้

นี่คือโค้ดกอล์ฟดังนั้นพยายามใช้ให้น้อยที่สุดในภาษาที่คุณเลือก

JavaScript (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%

คำอธิบาย: ครึ่งล่างของคิวบ์วาดโดยสะท้อนครึ่งบน แบ่งครึ่งออกเป็นครึ่งส่วนหกเจ็ด สามแถบตามแผนภาพนี้แสดงครึ่งบน:

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% โดยปรับปรุงโค้ดที่แสดงส่วนบนถึงครึ่งล่าง บันทึกเกือบ 10% โดยการรวมแถบด้านซ้ายสองและกลางสามแถบ

Canvas ขนาด 36 ไบต์

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

ลองที่นี่!

SOGL V0.12 , 32 ไบต์

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

ลองที่นี่!

คำอธิบายง่ายๆ:
1. วนซ้ำสำหรับแต่ละ 1..x
2. สร้าง⌐รูปร่างด้วยความกว้างi*4+1และความสูง = (0-indexed)i // 2
3. แผ่นเพื่อให้ดูเหมือน⦧
4. ผนวกรูปร่าง "\" กับแนวนอน
5. แทรกขั้นตอนก่อนหน้า ข้างในที่ตรงกันข้าม 6. หลังจากทุกสิ่งทุกอย่าง

โปรแกรมเต็มรูปแบบ:

ø                                 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 ไบต์

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

Python 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])))

เคล็ดลับ:

ฟังก์ชั่นนี้ใช้เพื่อแลกเปลี่ยนทั้งหมด\ด้วย/และในทางกลับกัน
ยาว ๆ ใน 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

เรียกใช้อันนี้

Haskell, 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 ทั้งหมดในรูปหลายเหลี่ยมเดียวหมายความว่าเคอร์เซอร์สิ้นสุดในตำแหน่งที่น่าอึดอัดใจซึ่งมีค่าใช้จ่ายในการแก้ไขจำนวนไบต์มากเกินไป)

Ｇ←⁴↘⊕⊗ι→⁴\

พิมพ์ด้านซ้ายสี่แถว\s (แถวที่ห้ามาจากคิวบ์ก่อนหน้า)

Ｍ⁴→

ย้ายไปที่จุดเริ่มต้นของคิวบ์ถัดไป

‖Ｔ»

สะท้อนให้เห็นถึงแนวนอนพร้อมสำหรับลูกบาศก์ต่อไป

‖Ｍ↓

สะท้อนทุกอย่างในแนวตั้งเพื่อทำให้ลูกบาศก์เสร็จสมบูรณ์