Escribano Casciitum

23

Introducción

Los cactus vienen en diferentes tamaños, formas y colores. Sin embargo, el cactus más emblemático y imprescindible en todos los occidentales tiene que ser el saguaro . Las características importantes son su tamaño y brazos, que han definido la apariencia estereotípica de los cactus.

Su tarea es traer el saguaro al mundo ASCII. Sin embargo, como en el mundo real, ningún saguaro es como otro, por lo que su programa debe ser capaz de generar saguaros con diferentes configuraciones de brazo.

Un ejemplo de saguaro

  • Entrada: [0b10, 0b11]( [2, 3]en decimal, longitud de entrada de 2)
     _     
    / \    
 _  | |    
/ \ | |    
| | | |    
\ \_| |    
 \__  |    
    \ |    
 _  | |  _ 
/ \ | | / \
| | | | | |
\ \_| |_/ /
 \__   __/ 
    \ /    
    | |    
    | |

Presupuesto

Un saguaro siempre tiene una base y una parte superior, con cantidades variables de tallo en el medio. Las partes del tallo no pueden tener brazos, un brazo a la derecha, uno a la izquierda o dos brazos.

Los patrones de crecimiento de Saguaro se proporcionan como una lista de entrada que contiene valores de dos bits. 00significa sin brazos, 01un brazo a la derecha, 10un brazo a la izquierda y11 dos brazos (todo en binario). La longitud de la lista de entrada determina la altura del saguaro.

Las secciones de Saguaro tienen el siguiente aspecto. Las partes del cactus están rodeadas de octothorps #, para mayor claridad que no se imprimirá.
La altura de un saguaro siempre es igual a los 4+6*kcaracteres para enteros no negativos k.

#############
#     _     # Saguaro top
#    / \    #
#############
# _  | |  _ # Stem, both arms
#/ \ | | / \# Stem id: 11
#| | | | | |#
#\ \_| |_/ /#
# \__   __/ #
#    \ /    #
#############
# _  | |    # Stem, left arm
#/ \ | |    # Stem id: 10
#| | | |    #
#\ \_| |    #
# \__  |    #
#    \ |    #
#############
#    | |  _ # Stem, right arm
#    | | / \# Stem id: 01
#    | | | |#
#    | |_/ /#
#    |  __/ #
#    | /    #
#############
#    | |    # Stem, no arms
#    | |    # Stem id: 00
#    | |    #
#    | |    #
#    | |    #
#    | |    #
#############
#    | |    # Saguaro base
#    | |    #
#############

Entrada

Como se dijo anteriormente, la entrada consiste en una lista de valores de dos bits ( 0, 1, 2, 3en decimal). Se puede dar en cualquier formato razonable. El primer elemento de la lista corresponde a la parte más alta del tallo del saguaro, el segundo elemento a su segunda parte más alta del tallo, etc.
Si lo desea, puede requerir la longitud de la lista de entrada como una entrada adicional. Especifíquelo en su respuesta si lo hace.

Salida

Su salida ASCII saguaro debe construirse utilizando las partes exactas del vástago como se describió anteriormente. Los espacios finales en una línea y las nuevas líneas finales se ignoran; puede imprimir más, menos o tantos como se especifica arriba.

Reglas

  • Se aplican lagunas estándar
  • Siendo este código de golf , el recuento de bytes de un programa debe ser mínimo

Casos de prueba

  • Un valor atípico. Entrada:[0b01, 0b00, 0b01, 0b11]
     _     
    / \    
    | |  _ 
    | | / \
    | | | |
    | |_/ /
    |  __/ 
    | /    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |  _ 
    | | / \
    | | | |
    | |_/ /
    |  __/ 
    | /    
 _  | |  _ 
/ \ | | / \
| | | | | |
\ \_| |_/ /
 \__   __/ 
    \ /    
    | |    
    | |
  • Alternancia de brazos. Entrada:[0b10, 0b01, 0b10]
     _     
    / \    
 _  | |    
/ \ | |    
| | | |    
\ \_| |    
 \__  |    
    \ |    
    | |  _ 
    | | / \
    | | | |
    | |_/ /
    |  __/ 
    | /    
 _  | |    
/ \ | |    
| | | |    
\ \_| |    
 \__  |    
    \ |    
    | |    
    | |
  • Una abundancia de armas. Entrada:[0b11, 0b11]
     _     
    / \    
 _  | |  _ 
/ \ | | / \
| | | | | |
\ \_| |_/ /
 \__   __/ 
    \ /    
 _  | |  _ 
/ \ | | / \
| | | | | |
\ \_| |_/ /
 \__   __/ 
    \ /    
    | |    
    | |
  • Sin armas, también conocido como lanza. Entrada:[0b00]
     _     
    / \    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |
  • Sin cuerpo, algunos lo llaman un cactus joven. Entrada:[]
     _     
    / \    
    | |    
    | |
code-golf ascii-art kolmogorov-complexity Jonathan Frech
fuente
¿Puedo tomar la entrada como la cantidad de partes y luego cada número de partes por separado? (por ejemplo, el primer caso de prueba sería 4 1 0 1 3)
dzaima
¿podemos ignorar los espacios finales?
Brian H.
@dzaima Puedes.
Jonathan Frech
@BrianH. Sí; los espacios finales se ignoran en cada línea.
Jonathan Frech

Respuestas:

10

carbón de leña , 50 49 bytes

↘_\¶/Ｆ²«Ｊ¹¦²Ｆθ¿﹪÷Ｉκ⁺¹ι²”{➙∧⊟≕δaL7ＹF¬⊕ρ↥↖_K”↓⁶↓²‖Ｔ

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

↘_\¶/

Dibuja la parte superior.

Ｆ²«

Pase sobre cada lado.

Ｊ¹¦²

Salta justo debajo del lado derecho de la parte superior.

Ｆθ

Pase sobre cada parte del tallo.

¿﹪÷Ｉκ⁺¹ι²

Prueba si hay un brazo.

”{➙∧⊟≕δaL7ＹF¬⊕ρ↥↖_K”

Si es así, imprima un brazo.

↓⁶

De lo contrario, solo imprima una línea vertical.

↓²

Después de imprimir el tallo, imprima la base.

‖Ｔ

Reflexiona listo para dibujar el otro lado. Una vez que se dibujan ambos lados, los lados se reflejan nuevamente en su posición final.

Neil
fuente
7

JavaScript (ES6), 210 bytes

Pasé demasiado tiempo en otra solución antes de darme cuenta de que había una mejor manera, que no me dejó tanto tiempo como me hubiera gustado trabajar en esto.

a=>`     _
    / \\`+a.map(([x,y])=>`
 1  | |  2
3 5 | | 4 6
7 7 | | 8 8
5 51| |24 4
 511${`| `[x]} ${`| `[y]}224
    ${`|\\`[x]} `.replace(/\d/g,m=>` _/\\|`[m%2?x*-~m/2:y*m/2])+`|/`[y],s=`
    | |`).join``+s+s

Intentalo

o.innerText=(f=
a=>`     _
    / \\`+a.map(([x,y])=>`
 1  | |  2
3 5 | | 4 6
7 7 | | 8 8
5 51| |24 4
 511${"| "[x]} ${"| "[y]}224
    ${"|\\"[x]} `.replace(/\d/g,m=>` _/\\|`[m%2?x*-~m/2:y*m/2])+"|/"[y],s=`
    | |`).join``+s+s
)(i.value=["11","10","01","00"]);oninput=_=>o.innerText=f(i.value.split`,`)
<input id=i><pre id=o>
Expandir fragmento

Lanudo
fuente
esto al tomar literal 00,01,10,11como entrada, en lugar de entrada binaria o 0,1,2,3. usando casos de prueba OP esto falla.
Brian H.
@BrianH .: Citando la especificación del desafío en la entrada: " Se puede dar en cualquier formato razonable "
Shaggy
1
pero establece que "la entrada consiste en una lista de valores de dos bits (0, 1, 2, 3 en decimal)". justo antes de eso ... (por cierto, no estoy votando ni nada, esto es increíblemente inteligente, es solo que, según mi interpretación de las reglas, la entrada no coincide)
Brian H.
5

Python 2 , 189 bytes

lambda l:'     _\n    / \\\n'+'\n'.join(('    |',' /|\  _   \  \|\_    __ |||| \\'[j::6])[i/2]+' '+('|','|||| /   __  /|/_ _   /  \|/'[j::6])[i%2]for i in l for j in range(6))+'\n    | |'*2

Pruébalo en línea!

Erik el Outgolfer
fuente
3

Python 2 , 256 253 ... 205 203 199 bytes

r=[('     _',''),('/','\ ')]
for a in input()+[0]:r+=zip(*[['|'*6,'_|    |_,,/|  \/  |\,,||  ||  ||,,\| _\/_ |/,,\ ____ /,,\/'[i::2].split(',')][2-i&a>0]for i in 0,1])
for l in r[:-4]:print'%5s %s'%l

Pruébalo en línea!

TFeld
fuente
Como lo hace en otros literales de cadena, en la primera línea puede omitir la barra invertida de escape.
Jonathan Frech
Parece que podría ahorrar 18 bytes eliminando todos los espacios finales.
Shaggy
for ...:\n r...\n r...-> for ...:r...;r...ahorra tres bytes.
Jonathan Frech
1

PowerShell , 235 bytes

param($a)'     _
    / \'
($a|%{((,'1|'*6),('1|  _
1| / \
1|2
1|_/ /
1 __/ 
1/'),(' _ 2
/ \2
| |2
\ \_| |
 \__  |
    \ |'),(' _ 2  _
/ \2 / \
| |22
\ \_| |_/ /
 \__   __/
    \ /'))[$_]})-replace1,'    | '-replace2,' | |'
,'    | |'*2

Pruébalo en línea!

PowerShell no tiene un map ozip o una manera fácil real para revertir cadenas, por lo que nos queda algo más - reemplazos simples de secciones repetidas.

Las primeras dos líneas toman la entrada como una matriz de enteros y generan la parte superior del cactus. Luego recorremos$a y seleccionamos en una matriz de cuatro cadenas según el valor actual. Esas cadenas se dejan en la tubería y luego usamos nuestro-replace para llenar los espacios apropiados. Luego colocamos el fondo del cactus en la tubería también.

Todo se recopila de la canalización y Write-Outputsucede implícitamente al finalizar el programa, insertando una nueva línea entre cada elemento.

AdmBorkBork
fuente
1

05AB1E , 76 75 bytes

„ _…/ \‚4ú»,v6F'|4ú"_ |/\"•Aö¡Èèj{^ë•5вèJ5ôNè©‚y1›èð'|®∞2äθ‚yÉèJ,}}„| 4úû=,

Pruébalo en línea!

Emigna
fuente
1
Meh, voy a tratar de vencerte, aunque lo dudo.
Urna de pulpo mágico
@MagicOctopusUrn: ¡Buena suerte! Espero que lo
consigas
Mi única buena idea para vencer esto fue aplastada por unos 30 bytes b / c del comando que publiqué en el chat "oasis / 05AB1E". Buen golf, si lo intentara ahora estaría demasiado cerca.
Urna mágica de pulpo
1

Java (OpenJDK 8) , 626 566 499 466 398 312 310 308 bytes

Se puede jugar golf una tonelada

a->{String r=" |,",g="    |",n="     _,    / \\,";boolean j,k;for(int e:a)n+=((k=e>1)?" _  |":g)+((j=e%2>0)?" |  _,":r)+(k?"/ \\ |":g)+(j?" | / \\,":r)+(k?"| | |":g)+(j?" | | |,":r)+(k?"\\ \\_|":g)+(j?" |_/ /,":r)+(k?" \\__ ":g)+(j?"  __/,":r)+(k?"    \\":g)+(j?" /,":r);return(n+g+r+g+r).replace(",","\n");}

Pruébalo en línea!

Roberto Graham
fuente
1
Puede guardar 2 bytes cambiando {j=e>1;k=e%2>0;n+=(k?" _ |":g)+(j?" | _,":r)+a n+=((k=e%2>0)?" _ |":g)+((j=e>1)?" | _,":r)+y retirar el cierre }del bucle para así.
Kevin Cruijssen
Tienes los "brazos" al revés para 1y 2.
Shaggy
0

SOGL V0.12 , 56 54 53 bytes

5⁷yΙ‚‘∑≡`a#¾‘O.{@.2%i»¹{"⁸G‘6∙;?X"j1>ζ╔²i[n¹‘5n}┼±↔}O

Pruébalo aquí!

Explicación:

..‘                   push the ending part - "    | |\n    | |"
   ..‘O               output the starting part - "     _ \n    / \"
       .{             input times do
         @              push a space
          .2%           push input%2
             i»         push floor(prevInput/2)
               ¹        wrap the two in an array

{                   }   for each of the two numbers
 "..‘                     push "|    " - base stem
     6∙                   multiply vertically 6 times
       ;?       }         if the current item iterating over is truthy (i.e. != 0)
         X                  remove ToS - the regular stem - from the stack 
          "..‘              push "|  _ | / \| | ||_/ / __/ /    " - stem with an arm
              5n            split it into line lengths of 5
                 ┼        add that horizontally to the space pushed earlier (or whatever it's become)
                  ±↔      reverse ToS - the stem currently - horizontally
                     O  output the array of the current part
dzaima
fuente