introduzione

I cactus sono disponibili in varie dimensioni, forme e colori. Tuttavia, il cactus e il must-have più iconico in ogni occidentale deve essere il saguaro . Caratteristiche importanti sono le sue dimensioni e le braccia, che hanno definito l'aspetto stereotipato del cactus.

Il tuo compito è portare il saguaro nel mondo ASCII. Tuttavia, come nel mondo reale, nessun saguaro è come un altro, quindi il tuo programma deve essere in grado di generare saguari con diverse configurazioni del braccio.

Un esempio di saguaro

• Input: [0b10, 0b11]( [2, 3]in decimale, lunghezza input di 2)

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

specificazioni

Un saguaro ha sempre una base e una cima, con quantità variabili di stelo in mezzo. Le parti dello stelo non possono avere braccia, un braccio a destra, uno a sinistra o due bracci.

I modelli di crescita del Saguaro sono indicati come un elenco di input contenente valori a due bit. 00significa niente braccia, 01un braccio a destra, 10un braccio a sinistra e 11due braccia (tutto in binario). La lunghezza dell'elenco di input determina l'altezza del saguaro.

Le sezioni del Saguaro sono le seguenti. Le parti di cactus sono circondate da ottotorpi #, per chiarezza che non devono essere stampate.
L'altezza di un saguaro è sempre uguale ai 4+6*kcaratteri per numeri interi non negativi 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
#    | |    #
#############

Ingresso

Come detto in precedenza, l'ingresso è costituito da un elenco di valori a due bit ( 0, 1, 2, 3in decimale). Può essere fornito in qualsiasi formato ragionevole. Il primo elemento dell'elenco corrisponde alla parte più alta dello stelo del saguaro, il secondo elemento alla sua seconda parte più alta dello stelo, ecc.
Se lo si desidera, è possibile richiedere la lunghezza dell'elenco di input come input aggiuntivo. Per favore specificalo nella tua risposta se lo fai.

Produzione

Il tuo saguaro ASCII di output dovrebbe essere costruito usando le parti esatte dello stelo come descritto sopra. Gli spazi finali su una linea e quelli nuovi vengono ignorati; è possibile stampare più, meno o quanti sono stati indicati sopra.

Regole

• Si applicano scappatoie standard
• Essendo code-golf , il conteggio dei byte di un programma dovrebbe essere minimo

Casi test

• Un outlier. Ingresso:[0b01, 0b00, 0b01, 0b11]

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

• Bracci alternati. Ingresso:[0b10, 0b01, 0b10]

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

• Un'abbondanza di armi. Ingresso:[0b11, 0b11]

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

• Nessuna arma, nota anche come lancia. Ingresso:[0b00]

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

• Nessun corpo, alcuni lo chiamano un giovane cactus. Ingresso:[]

     _     
    / \    
    | |    
    | |    

Carbone di legna , 50 49 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

↘_\¶/

Disegna la parte superiore.

Ｆ²«

Passa sopra ogni lato.

Ｊ¹¦²

Vai a sotto il lato destro della parte superiore.

Ｆθ

Passa sopra ogni parte dello stelo.

¿﹪÷Ｉκ⁺¹ι²

Verifica se c'è un braccio.

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

In tal caso, stampare un braccio.

↓⁶

Altrimenti basta stampare una linea verticale.

↓²

Dopo aver stampato lo stelo, stampare la base.

‖Ｔ

Rifletti pronto a disegnare l'altro lato. Una volta disegnati entrambi i lati, i lati vengono quindi riflessi nella loro posizione finale.

JavaScript (ES6), 210 byte

Ho trascorso troppo tempo su un'altra soluzione prima di rendermi conto che c'era un modo migliore, che non mi ha lasciato tutto il tempo che mi sarebbe piaciuto lavorare su questo.

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

Provalo

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 byte

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

Provalo online!

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

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

Provalo online!

PowerShell , 235 byte

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

Provalo online!

PowerShell non dispone di una mapo di zipo di un vero e proprio modo semplice per le stringhe di invertire, quindi siamo lasciati con qualcos'altro - semplici sostituzioni di sezioni ripetute.

Le prime due righe prendono input come una matrice di numeri interi e producono la parte superiore del cactus. Quindi eseguiamo il loop $ae selezioniamo un array di quattro stringhe in base al valore corrente. Quelle stringhe vengono lasciate sulla pipeline e quindi usiamo le nostre -replaceper riempire i punti appropriati. Quindi mettiamo anche il fondo del cactus sulla tubazione.

Tutto viene raccolto dalla pipeline e un implicito Write-Outputaccade al completamento del programma, inserendo una nuova riga tra ogni elemento.

05AB1E , 76 75 byte

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

Provalo online!

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

Può essere giocato a golf una tonnellata

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

Provalo online!

SOGL V0.12 , 56 54 53 byte

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

Provalo qui!

Spiegazione:

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