Il primo cubo Ascii (PAC 1) completato dal predecessore è un cubo semplice con lunghezza laterale 1 e si presenta così:

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

Il PAC 2 ha una forma geometrica tale che combinandolo con il suo predecessore (il PAC 1 ) completa un cubo di lunghezza 2 laterale:

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

Poiché la vista posteriore è un po 'noiosa, ci interessa solo la vista frontale .

Lo stesso vale per PAC 3 : con un po 'di pensiero visivo, PAC 2 può essere ruotato e inserito nel PAC 3 per formare un cubo solido di lunghezza laterale 3:

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

E così via con PAC 4 :

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

Compito:

Scrivere un programma completo o una funzione che accetta un intero positivo n come input e restituisce o stampa la vista frontale corrispondente di PAC n esattamente come mostrato sopra. Sono ammessi ulteriori spazi bianchi finali.

Questo è code-golf , quindi cerca di usare il minor numero di byte possibile nella lingua che preferisci.

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>

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

Spiegazione: La metà inferiore del cubo viene disegnata riflettendo la metà superiore. Le metà sono ulteriormente divise in sette sei tre parti di strisce , come da questo diagramma che mostra la metà superiore:

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. Il rientro (che diminuisce ogni riga) e il triangolo sinistro, che aumenta ogni altra riga
2. Il triangolo a zigzag che si restringe al centro, con il piccolo triangolo sui lati alternati ogni altra riga
3. Il triangolo destro, che aumenta in sincronia con la sinistra

Modifica: risparmiato oltre il 20% migliorando il codice che rifletteva la parte superiore nella metà inferiore. Risparmiato quasi il 10% unendo le due strisce centrali e due a sinistra.

Tela , 36 byte

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

Provalo qui!

SOGL V0.12 , 32 byte

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

Provalo qui!

Spiegazione semplice:
1. iterare per ciascuna di 1..x
2. creare una ⌐forma con larghezza i*4+1e altezza = (0-indexed)i // 2
3. riempirla in modo che appaia ⦧
4. aggiungere una forma "\" a quella orizzontale
5. inserire il passaggio precedente dentro quello invertito 6. dopo tutto, specchia verticalmente

programma completo:

ø                                 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

La funzione anonima nell'ultima riga accetta un argomento intero e produce le righe da stampare per un cubo di quella dimensione.

L'idea è di usare la ricorsione per disegnare cubi più grandi da quelli più piccoli. Vediamo la metà superiore di un cubo di dimensione 1. Quindi otteniamo la metà superiore di un cubo di dimensione 2 rispecchiando la metà precedente e aggiungendo un modello fisso di barre e spazi attorno ad esso:

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

Quindi l'algoritmo per disegnare un cubo di dimensione n è

1. Ottieni le linee per la metà superiore del cubo della dimensione n-1 .
2. Effettua il mirroring di ogni riga (capovolgendo /s e \s), pad ////e \intorno.
3. Prepara due righe con il motivo ////ⁿ più /\e / \.
4. Specchia le linee risultanti per ottenere il cubo completo.
5. Riempi le linee con il numero appropriato di spazi.

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

Provalo online!

crea una serie di n*4stringhe piene di spazi, quindi la sovrascrive con cubi successivamente più piccoli.

Codice commentato

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

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

Trucchi:

Questa funzione viene utilizzata per scambiare tutte \con /e viceversa
un po 'lungo in python2 - funziona solo con unicode
Partenza questo per come funziona

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

Genera nuove prime due righe per ogni iterazione
Per ora non riesco a trovare un modo compatto per ricevere queste righe dall'iterazione precedente

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

Invertire tutte le righe delle precedenti iterazioni e barre di scambio

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

Copia la metà superiore, invertita da righe, scambia le barre

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

Metodo accurato per le stringhe di imbottitura centrale

l.center(8*n)

Provalo online!

Stax , 36 byte

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

Esegui ed esegui il debug

Questo approccio crea iterativamente la metà superiore dell'output. Esegue il blocco principale il numero di volte specificato. In quel blocco, ogni riga è specchiata e ha un prefisso e un suffisso aggiunti. Le prime due nuove righe vengono aggiunte separatamente. Quando tutte le righe vengono create, sono centrate, quindi il fondo viene specchiato verticalmente.

Ecco il programma decompresso, ungolf e commentato.

{               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

Esegui questo

Haskell, 193 byte

Più lungo del vincitore, ma l'approccio può essere interessante - usa anche cose pi:)

Codice:

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

Eseguilo in questo modo:

mapM_ putStrLn (f 4)

Questo programma fondamentalmente "disegna" molti diamanti come questo:

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

La funzione i s e f"disegna" un diamante di dimensioni s, dove e, fsono (abs$z-y)(abs$z+y-1).

La funzione wsposta i diamanti estratti dai i punti corretti. headusato nella sua definizione è responsabile per guardare solo il livello più alto.

Provalo qui

Carbone , 42 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

ＦＮ«

Disegna i cubi dal più piccolo al più grande. (Disegnare dal più grande al più piccolo significava che ho finito con un'immagine speculare per numeri dispari che costavano troppi byte da correggere.)

↗×⊗⊕ι/

Stampa una riga di /s. (Questa diventerà la \s sulla destra, ma il disegno viene eseguito in modo speculare perché è più golfoso eseguire il mirroring alla fine del loop.)

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

Stampa le prime due file di \s. (Disegnando tutte le \s in un poligono significa che il cursore è finito in una posizione scomoda che è costata troppi byte da correggere.)

Ｇ←⁴↘⊕⊗ι→⁴\

Stampa a sinistra quattro righe di \s. (La quinta riga proviene dal cubo precedente.)

Ｍ⁴→

Passa all'inizio del cubo successivo.

‖Ｔ»

Rifletti orizzontalmente pronto per il cubo successivo.

‖Ｍ↓

Specchia tutto in verticale per completare il cubo.