Casciitum Scribe

23

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
la 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

Réponses:

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
la 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
la 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
la 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
la 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
la source
1

05AB1E , 76 75 octets

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

Essayez-le en ligne!

Emigna
la 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
la 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
la source