Introdução

Os cactos vêm em vários tamanhos, formas e cores diferentes. No entanto, o cacto mais emblemático e must-have em todos os ocidentais deve ser o saguaro . Características importantes são o tamanho e os braços, que definiram a aparência estereotipada dos cactos.

Sua tarefa é trazer o saguaro para o mundo ASCII. No entanto, - como no mundo real - nenhum saguaro é como outro, portanto, seu programa deve ser capaz de gerar saguaros com configurações de braço variáveis.

Um exemplo de saguaro

• Entrada: [0b10, 0b11]( [2, 3]em decimal, comprimento de entrada de 2)

     _     
    / \    
 _  | |    
/ \ | |    
| | | |    
\ \_| |    
 \__  |    
    \ |    
 _  | |  _ 
/ \ | | / \
| | | | | |
\ \_| |_/ /
 \__   __/ 
    \ /    
    | |    
    | |    

Especificações

Um saguaro sempre tem uma base e um topo, com quantidades variáveis ​​de caule no meio. As partes da haste não podem ter braços, um braço à direita, um à esquerda ou dois braços.

Os padrões de crescimento do Saguaro são fornecidos como uma lista de entrada contendo valores de dois bits. 00significa sem braços, 01um braço à direita, 10um braço à esquerda e11 dois braços (todos em binário). O comprimento da lista de entrada determina a altura do saguaro.

As seções do Saguaro são parecidas com as seguintes. As partes dos cactos são cercadas por octothorps #, para maior clareza que não deve ser impressa.
A altura de um saguaro é sempre igual a 4+6*kcaracteres para números inteiros não 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 dito anteriormente, a entrada consiste em uma lista de valores de dois bits ( 0, 1, 2, 3em decimal). Pode ser fornecido em qualquer formato razoável. O primeiro elemento da lista corresponde à parte mais alta do tronco do saguaro, o segundo elemento à sua segunda parte mais alta do tronco, etc.
Se desejar, você pode exigir o comprimento da lista de entrada como uma entrada adicional. Por favor, especifique-o na sua resposta, se o fizer.

Saída

Seu saguaro ASCII de saída deve ser construído usando as peças exatas da haste, conforme descrito acima. Os espaços à direita em uma linha e novas linhas à direita são ignorados; você pode imprimir mais, menos ou tantos quantos os especificados acima.

Regras

• Aplicam-se brechas padrão
• Sendo código-golfe , a contagem de bytes de um programa deve ser mínima

Casos de teste

• Um outlier. Entrada:[0b01, 0b00, 0b01, 0b11]

     _     
    / \    
    | |  _ 
    | | / \
    | | | |
    | |_/ /
    |  __/ 
    | /    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |  _ 
    | | / \
    | | | |
    | |_/ /
    |  __/ 
    | /    
 _  | |  _ 
/ \ | | / \
| | | | | |
\ \_| |_/ /
 \__   __/ 
    \ /    
    | |    
    | |    

• Braços alternados. Entrada:[0b10, 0b01, 0b10]

     _     
    / \    
 _  | |    
/ \ | |    
| | | |    
\ \_| |    
 \__  |    
    \ |    
    | |  _ 
    | | / \
    | | | |
    | |_/ /
    |  __/ 
    | /    
 _  | |    
/ \ | |    
| | | |    
\ \_| |    
 \__  |    
    \ |    
    | |    
    | |    

• Uma abundância de armas. Entrada:[0b11, 0b11]

     _     
    / \    
 _  | |  _ 
/ \ | | / \
| | | | | |
\ \_| |_/ /
 \__   __/ 
    \ /    
 _  | |  _ 
/ \ | | / \
| | | | | |
\ \_| |_/ /
 \__   __/ 
    \ /    
    | |    
    | |    

• Sem armas, também conhecida como lança. Entrada:[0b00]

     _     
    / \    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |    

• Nenhum corpo, alguns chamam de um cacto jovem. Entrada:[]

     _     
    / \    
    | |    
    | |    

Carvão , 50 49 bytes

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

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

↘_\¶/

Desenhe o topo.

Ｆ²«

Laço sobre cada lado.

Ｊ¹¦²

Ir para logo abaixo do lado direito da parte superior.

Ｆθ

Faça um loop sobre cada parte da haste.

¿﹪÷Ｉκ⁺¹ι²

Teste se existe um braço.

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

Se sim, imprima um braço.

↓⁶

Caso contrário, basta imprimir uma linha vertical.

↓²

Depois de imprimir a haste, imprima a base.

‖Ｔ

Reflita pronto para desenhar o outro lado. Depois que os dois lados são desenhados, os lados são refletidos de volta à sua posição final.

JavaScript (ES6), 210 bytes

Passei muito tempo em outra solução antes de perceber que havia uma maneira melhor, que não me deixou tanto tempo quanto eu gostaria de trabalhar nisso.

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

Tente

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>

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

Experimente online!

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

Experimente online!

PowerShell , 235 bytes

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

Experimente online!

O PowerShell não tem um mapou zipou uma maneira muito fácil de reverter cordas, por isso ficamos com algo mais - substituições simples de seções repetidas.

As duas primeiras linhas recebem a entrada como uma matriz de números inteiros e produzem a parte superior do cacto. Em seguida, fazemos um loop $ae selecionamos uma matriz de quatro strings com base no valor atual. Essas seqüências são deixadas no pipeline e então usamos nosso-replace para preencher os pontos apropriados. Em seguida, colocamos o fundo do cacto no oleoduto também.

Tudo é coletado do pipeline e um implícito Write-Outputacontece na conclusão do programa, inserindo uma nova linha entre cada elemento.

05AB1E , 76 75 bytes

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

Experimente online!

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

Pode ser jogado uma tonelada de golfe

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");}

Experimente online!

SOGL V0.12 , 56 54 53 bytes

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

Experimente aqui!

Explicação:

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