Wprowadzenie

Kaktusy występują w różnych rozmiarach, kształtach i kolorach. Jednak najbardziej charakterystycznym kaktusem i must-have w każdym westernu musi być saguaro . Ważnymi cechami są jego rozmiar i ramiona, które określają stereotypowy wygląd kaktusa.

Twoim zadaniem jest sprowadzenie saguaro do świata ASCII. Jednak - podobnie jak w prawdziwym świecie - żadne saguaro nie jest takie jak inne, więc twój program musi być w stanie generować saguaros z różnymi konfiguracjami ramion.

Przykład saguaro

• Dane wejściowe: [0b10, 0b11]( [2, 3]dziesiętnie, długość wejściowa 2)

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

Dane techniczne

Saguaro ma zawsze podstawę i górę, a pomiędzy nimi są zmienne ilości łodygi. Części trzonu nie mogą mieć ramion, ramienia po prawej stronie, ramienia po lewej ani dwóch ramion.

Wzorce wzrostu Saguaro podano jako listę wejściową zawierającą wartości dwubitowe. 00oznacza brak ramion, 01ramię po prawej, 10ramię po lewej i 11dwa ramiona (wszystkie w układzie dwójkowym). Długość listy wejściowej określa wysokość saguaro.

Sekcje Saguaro wyglądają następująco. Części kaktusa są otoczone oktorą #, dla jasności, która nie będzie drukowana.
Wysokość saguaro jest zawsze równa 4+6*kznakom dla liczb całkowitych nieujemnych 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
#    | |    #
#############

Wkład

Jak wspomniano wcześniej, dane wejściowe składają się z listy wartości dwubitowych ( 0, 1, 2, 3dziesiętnie). Można go podać w dowolnym rozsądnym formacie. Pierwszy element listy odpowiada najwyższej części pnia saguaro, drugi element do drugiej najwyższej części pnia itp.
Jeśli chcesz, możesz wymagać długości listy danych wejściowych jako dodatkowego wejścia. Jeśli tak, proszę podać to w odpowiedzi.

Wydajność

Twój wyjściowy saguaro ASCII powinien być zbudowany przy użyciu dokładnych części trzpienia, jak opisano powyżej. Końcowe spacje na linii i końcowe nowe linie są ignorowane; możesz wydrukować więcej, mniej lub tyle, ile określono powyżej.

Zasady

• Standardowe luki zastosowanie
• Ponieważ jest to golf kod , liczba bajtów programu powinna być minimalna

Przypadki testowe

• Wartość odstająca. Wkład:[0b01, 0b00, 0b01, 0b11]

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

• Ramiona naprzemienne. Wkład:[0b10, 0b01, 0b10]

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

• Obfitość broni. Wkład:[0b11, 0b11]

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

• Żadnych ramion, zwanych także włócznią. Wkład:[0b00]

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

• Żadnego ciała, niektórzy nazywają to młodym kaktusem. Wkład:[]

     _     
    / \    
    | |    
    | |    

Węgiel , 50 49 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

↘_\¶/

Narysuj górę.

Ｆ²«

Pętla po każdej stronie.

Ｊ¹¦²

Skocz na prawą stronę góry.

Ｆθ

Zapętlić każdą część łodygi.

¿﹪÷Ｉκ⁺¹ι²

Sprawdź, czy jest ramię.

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

Jeśli tak, wydrukuj ramię.

↓⁶

W przeciwnym razie po prostu wydrukuj linię pionową.

↓²

Po wydrukowaniu łodygi wydrukuj podstawę.

‖Ｔ

Odbicie gotowe do narysowania drugiej strony. Po narysowaniu obu stron, boki są następnie odbijane z powrotem do ich ostatecznej pozycji.

JavaScript (ES6), 210 bajtów

Spędziłem zdecydowanie za dużo czasu na innym rozwiązaniu, zanim zdałem sobie sprawę, że istnieje lepszy sposób, który nie dał mi tyle czasu, ile chciałbym nad tym popracować.

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

Spróbuj

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 bajtów

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

Wypróbuj online!

Python 2 , 256 253 ... 205 203 199 bajtów

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

Wypróbuj online!

PowerShell , 235 bajtów

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

Wypróbuj online!

PowerShell nie ma mapani zipłatwego sposobu na odwrócenie ciągów, więc pozostaje nam coś innego - proste zastąpienie powtarzających się sekcji.

Pierwsze dwa wiersze pobierają dane wejściowe jako tablicę liczb całkowitych i wyprowadzają górę kaktusa. Następnie zapętlamy $ai wybieramy tablicę czterech ciągów w oparciu o bieżącą wartość. Te ciągi są pozostawione na rurociągu, a następnie używamy naszego -replacedo wypełnienia odpowiednich miejsc. Następnie umieszczamy również dno kaktusa na rurociągu.

Wszystko jest gromadzone z potoku i niejawne Write-Outputdzieje się po zakończeniu programu, wstawiając nowy wiersz między każdym elementem.

05AB1E , 76 75 bajtów

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

Wypróbuj online!

Java (OpenJDK 8) , 626 566 499 466 398 312 310 308 bajtów

Można grać w golfa za tonę

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

Wypróbuj online!

SOGL V0.12 , 56 54 53 bajtów

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

Wypróbuj tutaj!

Wyjaśnienie:

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