Pierwsza kostka Ascii ukończona przez poprzednika (PAC 1) to prosta kostka o długości boku 1 i wygląda następująco:

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

PAC 2 ma kształt geometryczny tak, że połączenie go z jego poprzednika (The PAC 1 ) uzupełnia o boku 2 kostka:

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

Ponieważ widok z tyłu jest nudny, interesuje nas tylko widok z przodu .

To samo dotyczy PAC 3 : Przy odrobinie myślenia PAC 2 można odwrócić i podłączyć do PAC 3, aby utworzyć kostkę o solidnej długości 3:

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

I tak dalej z PAC 4 :

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

Zadanie:

Napisz pełny program lub funkcję, która przyjmuje na wejściu dodatnią liczbę całkowitą n i zwraca lub drukuje odpowiedni widok PAC n z przodu dokładnie tak, jak pokazano powyżej. Dopuszczalne są dodatkowe końcowe białe znaki.

To jest golf golfowy , więc spróbuj użyć jak najmniej bajtów w wybranym języku.

JavaScript (ES6), 229 bajtów

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>

Partia, 559 432 400 bajtów

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

Objaśnienie: Dolna połowa sześcianu jest rysowana poprzez odbicie górnej połowy. Połówki są dalej podzielone na siedem sześciu trzech pasków , zgodnie z tym schematem przedstawiającym górną połowę:

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. Wcięcie (które zmniejsza każdy wiersz) i lewy trójkąt, który zwiększa się co drugi rząd
2. Środkowy kurczący się zygzakowaty trójkąt, z małym trójkątem na przemian po bokach co drugi rząd
3. Prawy trójkąt, który rośnie w synchronizacji z lewym

Edycja: Oszczędź ponad 20%, ulepszając kod, który odzwierciedlał górę do dolnej połowy. Zaoszczędź prawie 10%, łącząc lewy dwa i środkowe trzy paski.

Płótno , 36 bajtów

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

Wypróbuj tutaj!

SOGL V0.12 , 32 bajty

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

Wypróbuj tutaj!

Proste wyjaśnienie:
1. iteruj dla każdego z 1..x
2. stwórz ⌐kształt o szerokości i*4+1i wysokości = (0-indexed)i // 2
3. wypełnij go tak, aby wyglądał jak ⦧
4. dodaj kształt „\” do tego poziomu
5. wstaw poprzedni krok wewnątrz tego odwróconego 6. po wszystkim lustro w pionie

pełny 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 bajtów

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

Funkcja anonimowa w ostatnim wierszu przyjmuje argument liczby całkowitej i zwraca wiersze do wydrukowania dla kostki o tym rozmiarze.

Chodzi o to, aby użyć rekurencji, aby narysować większe kostki z mniejszych. Spójrzmy na górną połowę sześcianu o rozmiarze 1. Następnie otrzymujemy górną połowę sześcianu o rozmiarze 2, odbijając lustro poprzednią połowę i dodając stały wzór ukośników i spacji wokół niej:

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

Tak więc algorytmem do narysowania kostki o rozmiarze n jest

1. Uzyskaj linie dla górnej połowy sześcianu o rozmiarze n-1 .
2. Wykonaj kopię lustrzaną każdej linii (odwracając /s i \s) oraz pad ////i \wokół.
3. Poprzedź dwie linie wzorem ////ⁿ plus /\i / \.
4. Odzwierciedlaj wynikowe linie, aby uzyskać pełny sześcian.
5. Wypełnij linie odpowiednią liczbą spacji.

Ruby , 174 167 169 167 bajtów

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

Wypróbuj online!

tworzy tablicę n*4 ciągów wypełnionych spacjami, a następnie zastępuje ją kolejno mniejszymi kostkami.

Skomentowany 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 bajtów

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

Wydziwianie:

Ta funkcja służy do zamiany wszystkich \z /i vice versa
trochę długo w python2 - działa tylko z unicode
Odjazd to na jak to działa

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

Generuje nowe dwa górne wiersze dla każdej iteracji
Na razie nie mogę znaleźć kompaktowego sposobu na otrzymanie tych linii z poprzedniej iteracji

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

Odwróć wszystkie wiersze poprzedniej iteracji i zamień ukośniki

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

Skopiuj górną połowę, odwróconą o rzędy, zamień ukośniki

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

Staranna metoda dla środkowych łańcuchów wypełniających

l.center(8*n)

Wypróbuj online!

Stax , 36 bajtów

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

Uruchom i debuguj

Takie podejście tworzy iteracyjnie górną połowę wyników. Wykonuje blok główny określoną liczbę razy. W tym bloku każdy wiersz jest dublowany i ma dodany prefiks i sufiks. Dwa górne nowe wiersze są dodawane osobno. Po zbudowaniu wszystkich rzędów są one wyśrodkowane, a następnie dno jest odbijane pionowo.

Oto program rozpakowany, nieposortowany i skomentowany.

{               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

Uruchom ten

Haskell, 193 bajty

Dłuższy niż zwycięzca, ale podejście może być interesujące - wykorzystuje nawet cosipi :)

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

Uruchom tak:

mapM_ putStrLn (f 4)

Ten program w zasadzie „rysuje” wiele diamentów takich jak ten:

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

Funkcja i s e f„rysuje” jeden diament wielkości s, gdzie e, fsą (abs$z-y)(abs$z+y-1).

Funkcja wprzesuwa ciągnione diamenty w i celu poprawienia miejsc. headużyte w jego definicji odpowiada tylko za najwyższą warstwę.

Wypróbuj tutaj

Węgiel drzewny , 42 bajty

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

ＦＮ«

Narysuj kostki od najmniejszej do największej. (Rysowanie od największego do najmniejszego oznaczało, że skończyłem z odbiciem lustrzanym dla liczb nieparzystych, których naprawienie kosztuje zbyt wiele bajtów).

↗×⊗⊕ι/

Wydrukuj linię /s. (To stanie się \literą po prawej, ale rysunek jest wykonywany w odbiciu lustrzanym, ponieważ golfist ma lustro na końcu pętli.)

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

Wydrukuj dwa górne rzędy \s. (Rysowanie wszystkich \s w jednym wielokącie oznaczało, że kursor znalazł się w niezręcznej pozycji, której naprawienie kosztowało zbyt wiele bajtów).

Ｇ←⁴↘⊕⊗ι→⁴\

Wydrukuj lewe cztery rzędy \s. (Piąty rząd pochodzi z poprzedniej kostki.)

Ｍ⁴→

Przejdź na początek następnej kostki.

‖Ｔ»

Odbij poziomo, gotowy do następnego sześcianu.

‖Ｍ↓

Odzwierciedlaj wszystko pionowo, aby ukończyć sześcian.