El primer Cubo Ascii completado por el predecesor (PAC 1) es un cubo simple con longitud lateral 1 y se ve así:

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

El PAC 2 es una forma geométrica tal que, combinándolo con su predecesor (el PAC 1 ) completa un cubo de longitud lateral 2:

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

Debido a que la vista posterior es un poco aburrida, solo nos interesa la vista frontal .

Lo mismo ocurre con el PAC 3 : con un poco de pensamiento visual, el PAC 2 se puede girar y enchufar en el PAC 3 para formar un cubo sólido de 3 lados:

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

Y así sucesivamente con PAC 4 :

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

Tarea:

Escriba un programa o función completa que tome un entero positivo n como entrada y devuelva o imprima la vista frontal correspondiente de PAC n exactamente como se muestra arriba. El espacio en blanco final adicional es aceptable.

Este es el código de golf , así que trate de usar la menor cantidad de bytes posible en el idioma que elija.

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%

Explicación: La mitad inferior del cubo se dibuja reflejando la mitad superior. Las mitades se dividen en siete seis tres partes de tiras , según este diagrama que muestra la mitad 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. La sangría (que disminuye cada fila) y el triángulo izquierdo, que aumenta cada dos filas
2. El triángulo en zigzag medio encogido, con el triángulo pequeño en lados alternos cada dos filas
3. El triángulo rectángulo, que aumenta en sincronización con el izquierdo

Editar: ahorró más del 20% al mejorar el código que reflejaba la mitad superior a la mitad inferior. Ahorró casi un 10% al fusionar las dos tiras izquierdas y las tres del medio.

Lienzo , 36 bytes.

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

Pruébalo aquí!

SOGL V0.12 , 32 bytes

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

Pruébalo aquí!

Explicación simple:
1. iterar para cada uno de los 1..x
2. hacer una ⌐forma con el ancho i*4+1y la altura = (0-indexed)i // 2
3. rellenarlo para que se vea como⦧
4. agrega una forma "\" horizontalmente
5. inserta el paso anterior dentro de ese reverso 6. después de todo, espejo verticalmente

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

La función anónima en la última línea toma un argumento entero y produce las líneas que se imprimirán para un cubo de ese tamaño.

La idea es utilizar la recursividad para dibujar cubos más grandes de los más pequeños. Veamos la mitad superior de un cubo de tamaño 1. Luego obtenemos la mitad superior de un cubo de tamaño 2 al reflejar la mitad anterior y agregar un patrón fijo de barras y espacios a su alrededor:

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

Entonces el algoritmo para dibujar un cubo de tamaño n es

1. Obtenga las líneas para la mitad del cubo superior de tamaño n-1 .
2. Espejo cada línea (por voltear /s e \s), y la almohadilla ////y \alrededor.
3. Anteponga dos líneas con el patrón ////ⁿ plus /\y / \.
4. Refleje las líneas resultantes para obtener el cubo completo.
5. Líneas de almohadilla con el número apropiado de espacios.

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

Pruébalo en línea!

crea una serie de n*4cadenas llenas de espacios, luego las sobrescribe con cubos sucesivamente más pequeños.

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

Trucos:

Esta función se utiliza para intercambio de todo \con /y viceversa
un poco largo en python2 - sólo funciona con Unicode
Salida esto para saber cómo funciona

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

Genera nuevas dos filas superiores para cada iteración
Por ahora no puedo encontrar una forma compacta de recibir estas líneas de la iteración anterior

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

Invierta todas las filas de la iteración anterior e intercambie barras inclinadas

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

Copie la mitad superior, invertida por filas, intercambie barras inclinadas

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

Método ordenado para cadenas de relleno central

l.center(8*n)

Pruébalo en línea!

Stax , 36 bytes

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

Ejecutar y depurarlo

Este enfoque acumula la mitad superior de la salida de forma iterativa. Ejecuta el bloque principal el número especificado de veces. En ese bloque, cada fila se refleja y tiene un prefijo y sufijo agregado. Las dos nuevas filas superiores se agregan por separado. Cuando se construyen todas las filas, se centran, y luego la parte inferior se refleja verticalmente.

Aquí está el programa desempaquetado, sin golf y 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

Ejecute este

Haskell, 193 bytes

Más largo que el ganador, pero el enfoque puede ser interesante: utiliza incluso cosy 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

Ejecútelo así:

mapM_ putStrLn (f 4)

Este programa básicamente 'dibuja' muchos diamantes como este:

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

La función i s e f'dibuja' un diamante de tamaño s, donde e, festán(abs$z-y)(abs$z+y-1) .

La función wmueve los diamantes dibujados i para corregir lugares. headutilizado en su definición es responsable de mirar solo la capa superior.

Pruébalo aquí

Carbón de leña , 42 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

ＦＮ«

Dibuja los cubos del más pequeño al más grande. (Dibujar del más grande al más pequeño significaba que terminé con una imagen especular para números impares que costaban demasiados bytes para arreglar).

↗×⊗⊕ι/

Imprime una línea de /s. (Esto se convertirá en la \s a la derecha, pero el dibujo se hace en espejo porque es más golfístico al espejo al final del bucle).

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

Imprima las dos primeras filas de \s. (Dibujar todas las \s en un polígono significaba que el cursor terminaba en una posición incómoda que costaba demasiados bytes para arreglar).

Ｇ←⁴↘⊕⊗ι→⁴\

Imprima las cuatro filas izquierdas del \s. (La quinta fila proviene del cubo anterior).

Ｍ⁴→

Ir al inicio del siguiente cubo.

‖Ｔ»

Refleje horizontalmente listo para el próximo cubo.

‖Ｍ↓

Refleje todo verticalmente para completar el cubo.