introduction

Les cactus sont disponibles en différentes tailles, formes et couleurs. Cependant, le cactus et les incontournables les plus emblématiques de tous les occidentaux doivent être le saguaro . Les caractéristiques importantes sont sa taille et ses bras, qui ont défini l'apparence stéréotypée du cactus.

Votre tâche est d'amener le saguaro dans le monde ASCII. Cependant, comme dans le monde réel, aucun saguaro n'est comme un autre, votre programme doit donc être capable de générer des saguaros avec différentes configurations de bras.

Un exemple saguaro

Entrée: [0b10, 0b11]( [2, 3]en décimal, longueur d'entrée de 2)

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

Caractéristiques

Un saguaro a toujours une base et un sommet, avec des quantités variables de tige entre les deux. Les parties de tige ne peuvent pas avoir de bras, un bras à droite, un à gauche ou deux bras.

Les modèles de croissance Saguaro sont donnés sous forme de liste d'entrée contenant des valeurs à deux bits. 00signifie pas de bras, 01un bras à droite, 10un bras à gauche et 11deux bras (tous en binaire). La longueur de la liste d'entrée détermine la hauteur du saguaro.

Les sections Saguaro ressemblent à ceci. Les parties de cactus sont entourées d'octothorps, #pour plus de clarté qui ne doit pas être imprimée.
La hauteur d'un saguaro est toujours égale aux 4+6*kcaractères des entiers non négatifs 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
#    | |    #
#############

Contribution

Comme indiqué précédemment, l'entrée se compose d'une liste de valeurs à deux bits ( 0, 1, 2, 3en décimal). Il peut être donné dans n'importe quel format raisonnable. Le premier élément de la liste correspond à la partie de tige la plus haute du saguaro, le deuxième élément à sa deuxième partie de tige la plus haute, etc.
Si vous le souhaitez, vous pouvez exiger la longueur de la liste d'entrée comme entrée supplémentaire. Veuillez le préciser dans votre réponse si vous le faites.

Sortie

Votre saguaro ASCII de sortie doit être construit en utilisant les pièces de tige exactes comme décrit ci-dessus. Les espaces de fin sur une ligne et les nouvelles lignes de fin sont ignorés; vous pouvez imprimer plus, moins ou autant que spécifié ci-dessus.

Règles

Des échappatoires standard s'appliquent
Ceci étant du code-golf , le nombre d'octets d'un programme doit être minimal

Cas de test

Une valeur aberrante. Contribution:[0b01, 0b00, 0b01, 0b11]

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

Bras alternés. Contribution:[0b10, 0b01, 0b10]

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

Une abondance d'armes. Contribution:[0b11, 0b11]

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

Pas d'armes, également connu comme une lance. Contribution:[0b00]

Aucun corps, certains l'appellent un jeune cactus. Contribution:[]

code-golf ascii-art kolmogorov-complexity

— Jonathan Frech
source

puis-je prendre l'entrée comme la quantité de pièces, puis chaque numéro de pièce séparément? (par exemple, le 1er test serait 4 1 0 1 3)

— dzaima

pouvons-nous ignorer les espaces de fuite?

— Brian H.

@dzaima Vous le pouvez.

— Jonathan Frech

@BrianH. Oui; les espaces de fin sont ignorés sur chaque ligne.

— Jonathan Frech

10

Fusain , 50 49 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

↘_\¶/

Dessinez le haut.

Ｆ²«

Boucle de chaque côté.

Ｊ¹¦²

Sautez juste sous le côté droit du haut.

Ｆθ

Boucle sur chaque partie de tige.

¿﹪÷Ｉκ⁺¹ι²

Testez s'il y a un bras.

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

Si c'est le cas, imprimez un bras.

↓⁶

Sinon, imprimez simplement une ligne verticale.

↓²

Après avoir imprimé la tige, imprimez la base.

‖Ｔ

Réfléchissez prêt à dessiner l'autre côté. Une fois que les deux côtés sont dessinés, les côtés sont reflétés dans leur position finale.

— Neil
source

7

JavaScript (ES6), 210 octets

J'ai passé beaucoup trop de temps sur une autre solution avant de réaliser qu'il y avait une meilleure solution, ce qui ne m'a pas laissé autant de temps que j'aurais aimé y travailler.

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

Essayez-le

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>

Développer l'extrait

— Hirsute
source

ceci en prenant le littéral 00,01,10,11en entrée, au lieu de l'entrée binaire ou 0,1,2,3. en utilisant des cas de test OP, cela échoue.

— Brian H.

@BrianH .: Citant la spécification du défi en entrée: " Elle peut être donnée dans n'importe quel format raisonnable "

— Shaggy

1

mais il indique "l'entrée se compose d'une liste de valeurs à deux bits (0, 1, 2, 3 en décimal)." juste avant cela ... (btw im pas downvoting ou anythin, c'est incroyablement intelligent, c'est juste que selon mon interprétation des règles l'entrée ne correspond pas)

— Brian H.

5

Python 2 , 189 octets

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

Essayez-le en ligne!

— Erik le Outgolfer
source

3

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

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

Essayez-le en ligne!

— TFeld
source

Comme vous le faites dans d'autres littéraux de chaîne, dans la première ligne, vous pouvez omettre la barre oblique inverse qui s'échappe.

— Jonathan Frech

Il semble que vous pourriez économiser 18 octets en supprimant tous les espaces de fin.

— Shaggy

for ...:\n r...\n r...-> for ...:r...;r...enregistre trois octets.

— Jonathan Frech

1

PowerShell , 235 octets

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

Essayez-le en ligne!

PowerShell ne dispose pas d'un mapou zipou d'un moyen très simple d'inverser les chaînes, nous nous retrouvons donc avec autre chose - de simples remplacements de sections répétées.

Les deux premières lignes prennent l'entrée comme un tableau d'entiers et sortent le haut du cactus. Ensuite, nous parcourons $aet sélectionnons un tableau de quatre chaînes en fonction de la valeur actuelle. Ces chaînes sont laissées sur le pipeline, puis nous utilisons notre-replace pour remplir les emplacements appropriés. Nous mettons ensuite le fond du cactus sur le pipeline également.

Tout est collecté à partir du pipeline et un implicite Write-Outputse produit à la fin du programme, insérant une nouvelle ligne entre chaque élément.

— AdmBorkBork
source

1

05AB1E , 76 75 octets

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

Essayez-le en ligne!

— Emigna
source

1

Meh, je vais essayer de te battre, j'en doute cependant.

— Urne de poulpe magique

@MagicOctopusUrn: Bonne chance! J'espère que vous y parviendrez (et peut-être la transformerez en escarmouche: P)

— Emigna

Ma seule bonne idée de battre cela a été écrasée par environ 30 octets b / c de la commande que j'ai publiée dans le chat "oasis / 05AB1E". Bon golf, si j'essayais maintenant, ce serait juste trop proche.

— Magic Octopus Urn

1

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

Peut être joué au golf une tonne

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

Essayez-le en ligne!

— Roberto Graham
source

1

Vous pouvez enregistrer 2 octets en changeant {j=e>1;k=e%2>0;n+=(k?" _ |":g)+(j?" | _,":r)+pour n+=((k=e%2>0)?" _ |":g)+((j=e>1)?" | _,":r)+et enlever la fermeture }de la boucle for ainsi.

— Kevin Cruijssen

Vous avez les "bras" dans le mauvais sens pour 1et 2.

— Shaggy

0

SOGL V0.12 , 56 54 53 octets

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

Essayez-le ici!

Explication:

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

Casciitum Scribe

introduction

Un exemple saguaro

Caractéristiques

Contribution

Sortie

Règles

Cas de test

Fusain , 50 49 octets

JavaScript (ES6), 210 octets

Essayez-le

Python 2 , 189 octets

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

PowerShell , 235 octets

05AB1E , 76 75 octets

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

SOGL V0.12 , 56 54 53 octets