O primeiro Ascii Cube (PAC 1) concluído com o antecessor é um cubo simples com comprimento lateral 1 e tem a seguinte aparência:

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

O PAC 2 é uma forma geométrica tal que combiná-lo com seu antecessor (o PAC 1 ) completa um cubo de comprimento lateral 2:

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

Como a visão traseira é meio chata, estamos interessados ​​apenas na visão frontal .

O mesmo vale para o PAC 3 : com algumas idéias visuais, o PAC 2 pode ser girado e conectado ao PAC 3 para formar um cubo sólido de comprimento lateral 3:

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

E assim por diante com o PAC 4 :

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

Tarefa:

Escreva um programa ou função completa que use um número inteiro positivo n como entrada e retorne ou imprima a vista frontal correspondente do PAC n exatamente como mostrado acima. Espaço em branco à direita adicional é aceitável.

Isso é código-golfe , então tente usar o mínimo de bytes possível no idioma de sua escolha.

JavaScript (ES6), 229 bytes

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>

Lote, 559 432 400 bytes

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

Explicação: A metade inferior do cubo é desenhada refletindo a metade superior. As metades são ainda divididas em sete seis três partes de tiras , conforme este diagrama que mostra a metade superior:

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. O recuo (que diminui todas as linhas) e o triângulo esquerdo, que aumenta todas as outras linhas
2. O triângulo em zigue-zague encolhido médio, com o pequeno triângulo em lados alternados a cada duas linhas
3. O triângulo direito, que aumenta em sincronia com o esquerdo

Editar: economizou mais de 20%, melhorando o código que refletia a parte superior para a metade inferior. Economizou quase 10% mesclando as duas faixas da esquerda e as três do meio.

Tela , 36 bytes

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

Experimente aqui!

SOGL V0.12 , 32 bytes

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

Experimente aqui!

Explicação simples:
1. itere para cada um de 1..x
2. faça uma ⌐forma com a largura i*4+1e a altura = (0-indexed)i // 2
3. preencha-a para que pareça ⦧
4. acrescente uma forma "\" horizontalmente
5. insira a etapa anterior dentro que inverteu 6. depois de tudo, espelho na vertical

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

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

A função anônima na última linha usa um argumento inteiro e produz as linhas a serem impressas para um cubo desse tamanho.

A idéia é usar a recursão para desenhar cubos maiores dos menores. Vamos olhar para a metade superior de um cubo de tamanho 1. Em seguida, obtemos a metade superior de um cubo de tamanho 2 espelhando a metade anterior e adicionamos um padrão fixo de barras e espaços ao seu redor:

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

Portanto, o algoritmo para desenhar um cubo de tamanho n é

1. Obtenha as linhas para a metade do cubo superior do tamanho n-1 .
2. Espelho cada linha (por lançando /s e \s), e uma almofada ////e \volta.
3. Anexe duas linhas com o padrão ////ⁿ mais /\e / \.
4. Espelhe as linhas resultantes para obter o cubo completo.
5. Preencher as linhas com o número apropriado de espaços.

Ruby , 174 167 169 167 bytes

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

Experimente online!

cria uma matriz de n*4cadeias preenchidas com espaços e a substitui por cubos sucessivamente menores.

Código comentado

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

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

Truques:

Esta função é utilizada para swap all \com /e vice-versa
um pouco longo em python2 - funciona apenas com unicode
Confira este para como ele funciona

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

Gera novas duas linhas principais para cada iteração
Por enquanto, não consigo encontrar uma maneira compacta de receber essas linhas da iteração anterior

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

Inverter todas as linhas da iteração anterior e trocar barras

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

Copie a metade superior, invertida por linhas, troque barras

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

Método elegante para cordas de preenchimento central

l.center(8*n)

Experimente online!

Stax , 36 bytes

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

Execute e depure

Essa abordagem cria a metade superior da saída de forma iterativa. Ele executa o bloco principal o número especificado de vezes. Nesse bloco, cada linha é espelhada e possui um prefixo e sufixo adicionados. As duas novas linhas principais são adicionadas separadamente. Quando todas as linhas são construídas, elas são centralizadas e a parte inferior é espelhada verticalmente.

Aqui está o programa descompactado, não destruído e comentado.

{               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

Execute este

Haskell, 193 bytes

Mais tempo que o vencedor, mas a abordagem pode ser interessante - usa par cose pi:)

Código:

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

Execute-o assim:

mapM_ putStrLn (f 4)

Este programa basicamente 'desenha' muitos diamantes como este:

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

A função i s e f'desenha' um diamante de tamanho s, onde e, festão (abs$z-y)(abs$z+y-1).

Função wmove os diamantes desenhados por i para corrigir locais. headusado em sua definição é responsável por examinar apenas a camada superior.

Experimente aqui

Carvão , 42 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

ＦＮ«

Desenhe os cubos do menor para o maior. (Desenhar do maior para o menor significava que eu acabei com uma imagem espelhada para números ímpares que custam muitos bytes para corrigir.)

↗×⊗⊕ι/

Imprima uma linha de /s. (Isso se tornará o \s à direita, mas o desenho é espelhado porque é mais espelhado no final do loop.)

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

Imprima as duas primeiras linhas de \s. (Desenhar todos os \s em um polígono significava que o cursor terminava em uma posição incômoda, que custava muitos bytes para corrigir.)

Ｇ←⁴↘⊕⊗ι→⁴\

Imprima as quatro linhas esquerdas de \s. (A quinta linha vem do cubo anterior.)

Ｍ⁴→

Vá para o início do próximo cubo.

‖Ｔ»

Reflita horizontalmente pronto para o próximo cubo.

‖Ｍ↓

Espelhe tudo verticalmente para concluir o cubo.