Ascii Cube (PAC 1) pertama yang selesai dengan Predecessor-selesai adalah kubus sederhana dengan panjang sisi 1 dan terlihat seperti ini:

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

The PAC 2 adalah bentuk geometris seperti yang menggabungkan dengan pendahulunya (yang PAC 1 ) melengkapi panjang sisi 2 kubus:

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

Karena tampilan belakang agak membosankan, kami hanya tertarik pada tampilan depan .

Hal yang sama berlaku untuk PAC 3 : Dengan beberapa pemikiran visual, PAC 2 dapat diputar dan dicolokkan ke PAC 3 untuk membentuk kubus panjang sisi 3:

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

Dan seterusnya dengan PAC 4 :

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

Tugas:

Tulis program atau fungsi lengkap yang mengambil bilangan bulat positif n sebagai input dan mengembalikan atau mencetak tampilan depan PAC yang sesuai n persis seperti yang ditunjukkan di atas. Ruang tambahan trailing putih dapat diterima.

Ini adalah kode-golf , jadi coba gunakan sesedikit mungkin byte dalam bahasa pilihan Anda.

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>

Batch, 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%

Penjelasan: Bagian bawah kubus ditarik dengan mencerminkan bagian atas. Bagian dibagi lebih lanjut menjadi tujuh enam tiga bagian strip , sesuai diagram ini menunjukkan bagian atas:

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. Lekukan (yang mengurangi setiap baris) dan segitiga kiri, yang meningkatkan setiap baris lainnya
2. Segitiga zigzag tengah menyusut, dengan segitiga kecil di sisi alternatif setiap baris lainnya
3. Segitiga kanan, yang meningkat sejalan dengan kiri

Sunting: Disimpan lebih dari 20% dengan meningkatkan kode yang mencerminkan bagian atas ke bawah. Menghemat hampir 10% dengan menggabungkan dua strip kiri dan tiga tengah.

Kanvas , 36 byte

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

Coba di sini!

SOGL V0.12 , 32 byte

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

Coba di sini!

Penjelasan sederhana:
1. iterate untuk masing-masing 1..x
2. buat ⌐bentuk dengan lebar i*4+1dan tinggi = (0-indexed)i // 2
3. padatkan sehingga terlihat seperti ⦧
4. tambahkan bentuk "\" ke arah itu secara horizontal
5. masukkan langkah sebelumnya di dalam itu terbalik 6. setelah semuanya, mirror secara vertikal

program lengkap:

ø                                 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

Fungsi anonim di baris terakhir mengambil argumen integer dan menghasilkan garis yang akan dicetak untuk kubus sebesar itu.

Idenya adalah menggunakan rekursi untuk menggambar kubus yang lebih besar dari yang lebih kecil. Mari kita lihat setengah bagian atas dari kubus ukuran 1. Kemudian kita mendapatkan bagian atas dari kubus ukuran 2 dengan mencerminkan bagian sebelumnya dan menambahkan pola garis miring dan spasi di sekitarnya:

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

Jadi algoritma untuk menggambar kubus ukuran n adalah

1. Dapatkan garis untuk setengah kubus atas ukuran n-1 .
2. Cermin setiap baris (dengan membalik /s dan \s), dan pad ////dan \sekitarnya.
3. Tambahkan dua baris dengan pola ////ⁿ plus /\dan / \.
4. Cermin garis yang dihasilkan untuk mendapatkan kubus penuh.
5. Pad baris dengan jumlah spasi yang sesuai.

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

Cobalah online!

menciptakan serangkaian n*4string yang diisi dengan spasi, lalu menimpanya dengan kubus yang lebih kecil secara berturut-turut.

Kode yang dikomentari

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

Akhirnya sub 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])))

Trik:

Fungsi ini digunakan untuk bertukar semua \dengan /dan sebaliknya
Agak panjang di Python2 - hanya bekerja dengan unicode
Lihat ini untuk cara kerjanya

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

Menghasilkan dua baris teratas baru untuk setiap iterasi
Untuk saat ini saya tidak dapat menemukan cara yang ringkas untuk menerima baris ini dari iterasi sebelumnya

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

Membalikkan semua baris iterasi sebelumnya dan menukar garis miring

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

Salin bagian atas, dibalik dengan baris, bertukar garis miring

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

Metode rapi untuk string padding tengah

l.center(8*n)

Cobalah online!

Stax , 36 byte

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

Jalankan dan debug itu

Pendekatan ini membangun setengah bagian atas output secara iteratif. Itu mengeksekusi blok utama beberapa kali yang ditentukan. Di blok itu, setiap baris dicerminkan dan memiliki awalan dan akhiran yang ditambahkan. Dua baris teratas baru ditambahkan secara terpisah. Ketika semua baris dibangun, mereka berpusat, dan kemudian bagian bawahnya dicerminkan secara vertikal.

Inilah programnya membongkar, tidak berkhasiat, dan berkomentar.

{               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

Jalankan yang ini

Haskell, 193 byte

Lebih panjang dari pemenang, tetapi pendekatannya mungkin menarik - menggunakan even cosand pi:)

Kode:

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

Jalankan seperti ini:

mapM_ putStrLn (f 4)

Program ini pada dasarnya 'menggambar' banyak berlian seperti ini:

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

Berfungsi i s e f'menggambar' satu ukuran berlian s, di mana e, fberada (abs$z-y)(abs$z+y-1).

Fungsi wmemindahkan berlian yang ditarik oleh i ke tempat yang benar. headdigunakan dalam definisinya bertanggung jawab untuk melihat lapisan paling atas saja.

Coba di sini

Arang , 42 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

ＦＮ«

Gambar kubus dari yang terkecil hingga yang terbesar. (Menggambar dari yang terbesar ke yang terkecil berarti saya berakhir dengan gambar cermin untuk angka ganjil yang membutuhkan terlalu banyak byte untuk diperbaiki.)

↗×⊗⊕ι/

Cetak satu baris /s. (Ini akan menjadi \huruf s di sebelah kanan, tetapi gambarnya selesai dicerminkan karena lebih indah untuk dicerminkan di akhir perulangan.)

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

Cetak dua baris atas \s. (Menggambar semua \s dalam satu poligon berarti kursor berakhir pada posisi yang canggung yang memerlukan terlalu banyak byte untuk diperbaiki.)

Ｇ←⁴↘⊕⊗ι→⁴\

Cetak empat baris kiri \s. (Baris kelima berasal dari kubus sebelumnya.)

Ｍ⁴→

Pindah ke awal kubus berikutnya.

‖Ｔ»

Merefleksikan siap secara horizontal untuk kubus berikutnya.

‖Ｍ↓

Cermin semuanya secara vertikal untuk menyelesaikan kubus.