Einführung

Kakteen gibt es in verschiedenen Größen, Formen und Farben. Allerdings muss der Saguaro der kultigste Kaktus und das Must-Have in jedem Western sein . Wichtige Merkmale sind seine Größe und seine Arme, die das stereotype Erscheinungsbild der Kakteen bestimmt haben.

Ihre Aufgabe ist es, den Saguaro in die ASCII-Welt zu bringen. Wie in der realen Welt gleicht jedoch kein Saguaro einem anderen. Daher muss Ihr Programm in der Lage sein, Saguaros mit unterschiedlichen Armkonfigurationen zu generieren.

Ein Beispiel Saguaro

• Eingabe: [0b10, 0b11]( [2, 3]in Dezimalzahl, Eingabelänge von 2)

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

Spezifikationen

Ein Saguaro hat immer eine Basis und eine Spitze mit variablen Mengen an Stiel dazwischen. Die Stielteile können keine Arme, einen Arm rechts, einen links oder zwei Arme haben.

Saguaro-Wachstumsmuster werden als Eingabeliste mit Zwei-Bit-Werten angegeben. 00bedeutet keine Arme, 01einen Arm rechts, 10einen Arm links und 11zwei Arme (alle in binärer Form). Die Länge der Eingabeliste bestimmt die Höhe des Saguaros.

Saguaro-Abschnitte sehen wie folgt aus. Kaktus-Teile sind aus Gründen der #Klarheit von Oktothorpen umgeben, die nicht gedruckt werden sollen.
Die Höhe eines Saguars entspricht immer den 4+6*kZeichen für nicht negative Ganzzahlen 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
#    | |    #
#############

Eingang

Wie bereits erwähnt, besteht die Eingabe aus einer Liste von Zwei-Bit-Werten ( 0, 1, 2, 3in Dezimalform). Es kann in jedem vernünftigen Format angegeben werden. Das erste Element der Liste entspricht dem höchsten Stammteil des Saguaros, das zweite Element dem zweithöchsten Stammteil usw.
Wenn Sie möchten, können Sie die Länge der Eingabeliste als zusätzliche Eingabe benötigen. Bitte geben Sie dies in Ihrer Antwort an.

Ausgabe

Ihr Ausgabe-ASCII-Saguaro sollte aus den exakten Stielteilen wie oben beschrieben erstellt werden. Nachgestellte Leerzeichen in einer Zeile und nachgestellte neue Zeilen werden ignoriert. Sie können mehr, weniger oder so viele wie oben angegeben drucken.

Regeln

• Standard Lücken gelten
• Da es sich um Code-Golf handelt , sollte die Byte-Anzahl eines Programms minimal sein

Testfälle

• Ein Ausreißer. Eingang:[0b01, 0b00, 0b01, 0b11]

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

• Wechselnde Arme. Eingang:[0b10, 0b01, 0b10]

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

• Eine Fülle von Waffen. Eingang:[0b11, 0b11]

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

• Keine Waffen, auch als Speer bekannt. Eingang:[0b00]

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

• Kein Körper, manche nennen es einen jungen Kaktus. Eingang:[]

     _     
    / \    
    | |    
    | |    

Kohle , 50 49 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

↘_\¶/

Zeichne die Spitze.

Ｆ²«

Schlaufe über jede Seite.

Ｊ¹¦²

Springe direkt unter die rechte Seite der Spitze.

Ｆθ

Schlinge über jedes Stielteil.

¿﹪÷Ｉκ⁺¹ι²

Prüfen Sie, ob ein Arm vorhanden ist.

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

Wenn ja, drucken Sie einen Arm.

↓⁶

Ansonsten drucken Sie einfach eine vertikale Linie.

↓²

Drucken Sie nach dem Drucken des Stiels die Basis.

‖Ｔ

Reflect bereit, die andere Seite zu zeichnen. Sobald beide Seiten gezeichnet sind, werden die Seiten in ihre endgültige Position zurückgespiegelt.

JavaScript (ES6), 210 Byte

Ich habe viel zu lange an einer anderen Lösung gearbeitet, bevor mir klar wurde, dass es einen besseren Weg gibt, der mir nicht so viel Zeit lässt, wie ich gerne daran gearbeitet hätte.

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

Versuch es

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

Probieren Sie es 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

Probieren Sie es 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

Probieren Sie es online!

In PowerShell gibt es weder eine mapnoch zipeine einfache Möglichkeit, Zeichenfolgen umzukehren. Daher bleibt uns noch etwas anderes übrig - einfaches Ersetzen von wiederholten Abschnitten.

Die ersten beiden Zeilen nehmen Eingaben als Array von Ganzzahlen entgegen und geben die Spitze des Kaktus aus. Dann durchlaufen wir eine Schleife $aund wählen basierend auf dem aktuellen Wert ein Array mit vier Zeichenfolgen aus. Diese Zeichenfolgen verbleiben in der Pipeline, und dann -replacefüllen wir die entsprechenden Stellen mit unserer aus . Dann setzen wir den Boden des Kaktus ebenfalls auf die Pipeline.

Alles wird aus der Pipeline gesammelt und ein implizites Write-OutputEreignis tritt beim Abschluss des Programms auf, wobei zwischen jedem Element eine neue Zeile eingefügt wird.

05AB1E , 76 75 Bytes

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

Probieren Sie es online!

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

Kann eine Tonne Golf gespielt werden

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

Probieren Sie es online!

SOGL V0.12 , 56 54 53 Bytes

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

Probieren Sie es hier aus!

Erläuterung:

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