Önceden tamamlanmış ilk Ascii Küpü (PAC 1) , yan uzunluğu 1 olan basit bir küptür ve şöyle görünür:

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

PAC 2 selefi (ile birleştirilmesi böyle bir geometrik şekil PAC 1 ) bir yan uzunluğu 2 küp tamamlar:

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

Çünkü geri -View tür sıkıcı, biz sadece ilgilenen edilir önünde -Manzaralı.

Aynı şey PAC 3 için de geçerlidir : Bazı görsel düşüncelerle PAC 2 geri döndürülebilir ve sağlam bir yan uzunluk 3 küp oluşturmak için PAC 3'e takılabilir :

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

Ve böylece PAC 4 ile :

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

Görev:

N, giriş ve geri dönüş veya baskı mukabil ön görünümü olarak bir pozitif tamsayıyı alır tam bir program ya da fonksiyonu Yazın PAC n tam olarak yukarıda gösterildiği gibi . Ek izleyen beyaz boşluk kabul edilebilir.

Bu kod-golf , bu yüzden seçtiğiniz dilde mümkün olduğunca az byte kullanmaya çalışın.

JavaScript (ES6), 229 bayt

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>

Toplu, 559 432 400 bayt

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

Açıklama: Küpün alt yarısı üst yarısı yansıtılarak çizilir. Yarımlar ayrıca üst yarıyı gösteren bu şemaya göre yedi altı üç şeritli parçaya bölünmüştür :

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. Girintileri (her satırda azalır) ve soldaki üçgen, bu da diğer tüm satırları artırır
2. Orta küçülen zikzak üçgeni, her iki sırada diğer taraflarda alternatif olan küçük üçgen
3. Sola senkronize artan sağ üçgen

Düzenleme: Yukarıdan aşağıya doğru yansıtan kodu geliştirerek% 20'nin üzerinde tasarruf sağlar. Sol iki ve orta üç şeridi birleştirerek neredeyse% 10 tasarruf edin.

Tuval , 36 bayt

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

Burada dene!

SOGL V0.12 , 32 bayt

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

Burada dene!

Basit açıklama:
1. 1.xx'in her biri için yineleyin
2. ⌐genişlik i*4+1ve yükseklik ile bir şekil oluşturun = (0-indexed)i // 2
3. gibi görünmesini sağlayın ⦧
4. yatay olarak bir "\" şekli
ekleyin 5. önceki adımı ekleyin bunun içinde tersine döndü 6. her şeyden sonra, dikey olarak aynalayın

tam program:

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

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

Son satırdaki adsız işlev bir tamsayı argümanını alır ve bu boyuttaki bir küp için yazdırılacak satırları verir.

Fikir, daha küçük küplerden daha büyük küpler çizmek için özyinelemeyi kullanmaktır. 1 büyüklüğünde bir küpün üst yarısına bakalım. Sonra eski yarımı yansıtarak 2 boyutunda bir küpün üst yarısını elde edip etrafına sabit bir eğik çizgi ve boşluk deseni ekleyebiliriz:

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

Boyutu algoritma, bir küp çizmek Yani n olan

1. N-1 boyutunun üst küpünün yarısı için satırları alın .
2. Her çizgiyi yansıtın ( /s ve \s çevirerek ), ve ped ////ve \etrafında.
3. ////^N artı desenli /\ve iki satırlı Prepend / \.
4. Dolu küpü elde etmek için ortaya çıkan çizgileri yansıtın.
5. Uygun sayıda boşluk içeren dolgu hatları.

Ruby , 174 167 169 167 bayt

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

Çevrimiçi deneyin!

n*4boşluklarla dolu bir dizi dizisi yaratır , ardından üzerine daha küçük küplerle yazar.

Yorumlanan kod

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

Sonunda 200 alt!

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

Püf nokta:

Bu fonksiyon tüm takas için kullanılır \ile /ve tersi
bir Python2 uzun bit - unicode ile çalışır
Giriş Çıkış bu nasıl çalıştığını için

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

Her yineleme
için yeni ilk iki satır oluşturur Şimdilik bu satırları önceki yinelemeden almanın kompakt yolunu bulamıyorum

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

Önceki yinelemenin tüm satırlarını ters çevir ve takas çizgilerini değiştir

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

Üst yarıyı kopyala, satırlarla ters çevir, takas çizgilerini değiştir

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

Merkez dolgusu dizeleri için temiz yöntem

l.center(8*n)

Çevrimiçi deneyin!

Stax , 36 bayt

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

Koş ve hata ayıkla

Bu yaklaşım, çıktının üst yarısını yinelemeli oluşturur. Ana bloğu belirtilen sayıda çalıştırır. Bu satırda, her satır yansıtılır ve bir önek ve sonek eklenir. En üstteki iki yeni satır ayrı olarak eklenir. Tüm satırlar oluşturulduğunda, ortalanırlar ve sonra altları dikey olarak yansıtılır.

İşte program, paketlenmemiş, ungolfed ve yorum yaptı.

{               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

Bunu çalıştır

Haskell, 193 bayt

Kazanandan daha uzun, ancak yaklaşım ilginç olabilir - hatta kullanır cosve pi:)

Kod:

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

Bu şekilde çalıştırın:

mapM_ putStrLn (f 4)

Bu program temelde bunun gibi birçok elması 'çizer':

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

Fonksiyon i s e fbüyüklükte bir elmas 'çizer' s, e, fvardır (abs$z-y)(abs$z+y-1).

İşlev w, i yerleri düzeltmek için çizilen elmasları hareket ettirir . headtanımında kullanılan, yalnızca en üst katmana bakmaktan sorumludur.

Burada dene

Kömür , 42 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

ＦＮ«

Küpleri en küçüğünden en büyüğüne çekin. (En büyüğünden en küçüğüne doğru çizim yapmak, düzeltilmesi çok fazla bayta mal olan tek sayılar için ayna görüntüsü verdiğim anlamına gelir.)

↗×⊗⊕ι/

/S satırı yazdır . (Bu \sağda s olacak , ancak çizim aynalı olarak yapılır çünkü döngünün sonunda yansıtmak için golf oynamaktadır.)

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

En üstteki iki satırı yazdırın \. (Tüm \s'lerin bir çokgene çizilmesi , imlecin düzeltilemeyecek kadar fazla bayta mal olan garip bir pozisyonda bitmesi anlamına geliyordu.)

Ｇ←⁴↘⊕⊗ι→⁴\

Soldaki dört \s satırını yazdırın . (Beşinci satır önceki küpten gelir.)

Ｍ⁴→

Bir sonraki küpün başlangıcına git.

‖Ｔ»

Sonraki küp için yatay olarak hazır düşünün.

‖Ｍ↓

Küpü tamamlamak için her şeyi dikey olarak yansıtın.