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.
Respuestas:
JavaScript (ES6), 229 bytes
fuente
Lote,
559432400 bytesExplicación: La mitad inferior del cubo se dibuja reflejando la mitad superior. Las mitades se dividen en
sieteseistres partes detiras, según este diagrama que muestra la mitad superior: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.
fuente
Lienzo , 36 bytes.
Pruébalo aquí!
fuente
SOGL V0.12 , 32 bytes
Pruébalo aquí!
Explicación simple:
1. iterar para cada uno de los 1..x
2. hacer una
⌐
forma con el anchoi*4+1
y 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:
fuente
Haskell ,
232227224187183180175 bytesLa 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
/
s e\
s), y la almohadilla////
y\
alrededor.////
n plus/\
y/ \
.fuente
g=
.(\l->r l++k(k m)l)
es lo mismo queliftM2 (++) r (k(k m))
, de nuevo, se puede acortar(++).r<*>k(k m)
. Pruébalo en línea!Rubí ,
174 167 169167 bytesPruébalo en línea!
crea una serie de
n*4
cadenas llenas de espacios, luego las sobrescribe con cubos sucesivamente más pequeños.Código comentado
fuente
Python 2 ,
254234226203201199 bytesFinalmente sub 200!
Trucos:
Esta función se utiliza para intercambio de todo
\
con/
y viceversaun poco largo en python2 - sólo funciona con Unicode
Salida esto para saber cómo funciona
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
Invierta todas las filas de la iteración anterior e intercambie barras inclinadas
Copie la mitad superior, invertida por filas, intercambie barras inclinadas
Método ordenado para cadenas de relleno central
Pruébalo en línea!
fuente
Stax , 36 bytes
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.
Ejecute este
fuente
Haskell, 193 bytes
Más largo que el ganador, pero el enfoque puede ser interesante: utiliza incluso
cos
ypi
:)Código:
Ejecútelo así:
Este programa básicamente 'dibuja' muchos diamantes como este:
La función
i s e f
'dibuja' un diamante de tamaños
, dondee, f
están(abs$z-y)(abs$z+y-1)
.La función
w
mueve los diamantes dibujadosi
para corregir lugares.head
utilizado en su definición es responsable de mirar solo la capa superior.Pruébalo aquí
fuente
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.
fuente