Die 21 Frisuren der Apokalypse

Bei einer Liste von Zahlen zwischen 1 und 21 (oder 0 und 20) wird eine "zusammengenähte" Zeichnung der folgenden Flächen ausgegeben ( siehe Regeln für Nähinformationen ):

     ___           ,,,           ooo           ===           +++           ###          -*~*-     
    (o o)         (o o)         (o o)         (o o)         (o o)         (o o)         (o o)     
ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-

     ***           |||           _/7           )))           (((           xxx           @__      
    (o o)         (o o)         (o o)         (o o)         (o o)         (o o)         (o o)     
ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-

     ((_           >X<           '*`           ^^^           )|(           \|/           &&&      
    (o o)         (o o)         (o o)         (o o)         (o o)         (o o)         (o o)     
ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-

Jedes einzelne Gesicht, das in einer neuen Zeile aufgeführt ist (das # ist die Ganzzahl-ID für das Gesicht):

     ___      
    (o o)     
ooO--(_)--Ooo #1

     ,,,      
    (o o)     
ooO--(_)--Ooo #2

     ooo      
    (o o)     
ooO--(_)--Ooo #3

     ===      
    (o o)     
ooO--(_)--Ooo #4

     +++      
    (o o)     
ooO--(_)--Ooo #5

     ###      
    (o o)     
ooO--(_)--Ooo #6

    -*~*-     
    (o o)     
ooO--(_)--Ooo #7

     ***      
    (o o)     
ooO--(_)--Ooo #8

     |||      
    (o o)     
ooO--(_)--Ooo #9

     _/7      
    (o o)     
ooO--(_)--Ooo #10

     )))      
    (o o)     
ooO--(_)--Ooo #11

     (((      
    (o o)     
ooO--(_)--Ooo #12

     xxx      
    (o o)     
ooO--(_)--Ooo #13

     @__      
    (o o)     
ooO--(_)--Ooo #14

     ((_      
    (o o)     
ooO--(_)--Ooo #15

     >X<      
    (o o)     
ooO--(_)--Ooo #16

     '*`      
    (o o)     
ooO--(_)--Ooo #17

     ^^^      
    (o o)     
ooO--(_)--Ooo #18

     )|(      
    (o o)     
ooO--(_)--Ooo #19

     \|/      
    (o o)     
ooO--(_)--Ooo #20

     &&&      
    (o o)     
ooO--(_)--Ooo #21

Das Gesicht ist wie folgt:

    hhhhh     
    (o o)     
ooO--(_)--OooS

Wo hist die dynamische apokalyptische Frisur und Sist der mögliche Stichbindestrich.

Beispiele

Eingang: [1,2,3,4,5]

Ausgabe:

     ___           ,,,           ooo           ===           +++      
    (o o)         (o o)         (o o)         (o o)         (o o)     
ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-

Eingang: [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21]

Ausgabe:

     ___           ,,,           ooo           ===           +++           ###          -*~*-          ***           |||           _/7           )))           (((           xxx           @__           ((_           >X<           '*`           ^^^           )|(           \|/           &&&      
    (o o)         (o o)         (o o)         (o o)         (o o)         (o o)         (o o)         (o o)         (o o)         (o o)         (o o)         (o o)         (o o)         (o o)         (o o)         (o o)         (o o)         (o o)         (o o)         (o o)         (o o)     
ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-

Eingabe: ["Fraggle Rock"] / [22]/ [-21041024]/[22,23,24,25,26]

Ausgabe: Nobody cares.

Eingang: [1,1,1,1]

Ausgabe:

     ___           ___           ___           ___      
    (o o)         (o o)         (o o)         (o o)     
ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-ooO--(_)--Ooo-

Regeln

• Vorhergehende und nachfolgende Zeilenumbrüche / Leerzeichen / Bindestriche sind in Ordnung.
• Gesichter können in der Eingabe mehrmals vorkommen.
• Wenn die Eingabe eine ungültige Nummer enthält, liegt möglicherweise ein undefiniertes Verhalten vor.
• Die Naht:
  • Die zusammengefügten Flächen werden durch einen einzelnen Bindestrich in der unteren (3.) Zeile verkettet.
  • Die Gesichter werden alle auf einer einzigen Linie sein (im Gegensatz zur ersten Zeichnung).
• Die Eingabe kann mit 0 oder 1 indiziert sein, wobei 20 für 0, 21 für 1 maximal ist.
• Dies ist Code-Golf , die niedrigste Anzahl an Bytes gewinnt.

Japt -R , 122 117 113 110 109 107 105 104 103 102 100 99 Bytes

1-indiziert, mit Indexumbruch. Ich habe hier die Spezifikation befolgt, die einen Bindestrich zwischen der letzten Zeile jedes Gesichts erfordert , und nicht die Testfälle, die einen Bindestrich nach der letzten Zeile jedes Gesichts enthalten.

[Umg"@__((_>X<'*`^^^)|(\\|/"i"&_,o=+#*|)(x"m³ ò3 i7"-*~"ê)iA"_/7")¡"(o o)"á"O--(_)--O"ûoDÃq-]ûD m¸

Versuch es

[                                             :Construct an array of 3 elements
Umg"@.../"i"&...x"m³ ò3 i7"-*~"ê)iA"_/7")     :FIRST ELEMENT (F)
U                                             :  Input array
 m                                            :  Map
  g                                           :    Index into
   "@.../"                                    :      Literal string
          i                                   :      Prepend
           "&...x"                            :        Literal string
                  m                           :        Map
                   ³                          :          Repeat 3 times
                     ò3                       :      Split into chucks of 3
                        i7                    :      Insert at 0-based index 7
                          "-*~"ê              :        "-*~" palindromised
                                )             :      End insert
                                 iA"_/7"      :      Insert "_/7" at index 10
                                        )     :  End map
¡"(o o)"Ã                                     :SECOND ELEMENT (S)
¡                                             :  Map input array
 "(o o)"                                      :    Literal string
        Ã                                     :  End map
¡"O...O"ûoDÃq-                                :THIRD ELEMENT (T)
¡                                             :  Map input array
 "O...O"                                      :    Literal string
        ûo                                    :    Centre pad with "o"
          D                                   :      To length 13
           Ã                                  :  End map
            q-                                :  Join with "-"
]                                             :End array
 ûD                                           :Centre pad each string in F & S to length 13 with spaces, does nothing to T as it will always be at least 13 characters long
    m                                         :Map
     ¸                                        :  Join F & S with spaces. Split T on spaces, creating a singleton array which gets cast back to a string on output
                                              :Implicit output, joined with newlines

Python 2 , 209 Bytes

def f(a):s=t=u='\n';i=0;exec"s+=(\"_,o=+#-*|_)(x@(>'^)\\&_,o=+#**|/)(x_(X*^||&_,o=+#~*|7)(x__<`^(/&\"[a[i]::21]+'*-'*(a[i]==6)).center(14);t+='    (o o)     ';u+='ooO--(_)--Ooo-';i+=1;"*len(a);print s+t+u[:-1]

Probieren Sie es online!

0-basierte Indizierung; hier nichts besonders Kluges, nur Daten, auf die per Slicing und Exec zugegriffen wird, anstatt einer Schleife.

Kohle , 103 102 Bytes

Ｅ²⪫Ｅθ⎇ι(o o)⪫ײ§ -⁼λ⁶§⪪”|″:αuxkτT↷K[ï�↔ς↨?◧BZ@C←↑⊞Ａ⧴M✂↶ºKf÷H#S⦃J&≔⁰∧5À³≕r‹▷”³λ× ⁹Ｍ⁴←⪫ＥθooO--(_)--Ooo¦-

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

Ｅ²⪫Ｅθ

Den Eingang zweimal durchlaufen. Jedes Ergebnis wird dann implizit in einer eigenen Zeile gedruckt.

⎇ι(o o)

Generieren Sie in der zweiten Schleife einfach die Augen.

⪫ײ§ -⁼λ⁶

Wickeln Sie Frisur 6 in -s, andere Frisuren in Räumen.

§⪪”|″:αuxkτT↷K[ï�↔ς↨?◧BZ@C←↑⊞Ａ⧴M✂↶ºKf÷H#S⦃J&≔⁰∧5À³≕r‹▷”³λ

Extrahieren Sie die drei Frisurzeichen aus einer komprimierten Zeichenfolge.

× ⁹

Fügen Sie neun Leerzeichen zwischen den Haaren oder Augen ein.

Ｍ⁴←

Verschiebe 4 Felder nach links.

⪫ＥθooO--(_)--Ooo¦-

Drucken Sie die restlichen Gesichter zusammen mit einem -.

R , 413 391 Bytes

Vielen Dank an Giuseppe für 22 weniger Bytes und dafür, dass diese unter 400 Bytes liegen.

function(s,n=length(s)){I=intToUtf8
U=utf8ToInt
R=rep
K=cat
a=U("_,o=+#^*|&)(x")
b=c("@__","((_",">X<","'*`","",")|(","\\|/","","-*~*-","_/7")
s[s==7]=22;s[s==10]=23;s[s==18]=7;s[s==21]=10
for(i in s)K(I(c(rep(32,4+(i!=22)),"if"(i<14,R(a[i],3),U(b[i-13])),R(32,5+(i!=22)))))
K("
",I(R(c(R(32,3),40,111,32,111,41,R(32,6)),n)),"
")
K(I(40+R(c(x<-c(71,71,39,5,5),0,55,1,rev(x),5),n)[-(14*n)]))}

Probieren Sie es online!

JavaScript (ES6), 200 bis 199 Byte

Erwartet eine 1-indizierte Eingabe.

a=>[1,0,2].map(y=>a.map(n=>s=y&2?'ooO--(_)--Ooo':`    ${p='( -'[y*n-7?y:2]}${"o o___,,,ooo===+++###*~****|||_/7)))(((xxx@__((_>X<'*`^^^)|(\\|/&&&".substr(y*n*3,3)}${y?p:')'}    `).join(s[3])).join`
`

Probieren Sie es online!

Kommentiert

a =>                              // given the input array a[]
  [1, 0, 2].map(y =>              // for each row y:
    a.map(n =>                    //   for each integer n in a[]:
      s =                         //     let s be the content of this row
        y & 2 ?                   //     if this is the 3rd row:
          'ooO--(_)--Ooo'         //       use a hardcoded string
        :                         //     else:
          `    ${                 //       append 4 spaces
            p = '( -'[            //       append and save in p:
              y * n - 7 ? y : 2   //         '(' if y = 0 (2nd row)
            ]                     //         ' ' if y = 1 and n != 7
          }${                     //         '-' if y = 1 and n = 7
            "o o___,,,ooo(...)"   //       append the middle pattern (NB: truncated string)
            .substr(y * n * 3, 3) //       which is always the eyes if y = 0
          }${                     //
            y ? p : ')'           //       append p for the 1st row or ')' for the 2nd row
          }    `                  //       append 4 spaces
    ).join(s[3])                  //   join with the 4th character of s (space or hyphen)
  ).join`\n`                      // join with line-feeds

Ruby , 164 Bytes

->a{puts a.map{|i|j="_,o=+# *| )(x    ^  &"[i];(j<?!?%w{@__ ((_ >X< '*` -*~*- )|( \|/ _/7}[i%11-2]:j*3).center(14)}*"","    (o o)     "*k=a.size,"ooO--(_)--Ooo-"*k}

Null indiziert. Probieren Sie es online!

Das ganze schwierige Zeug passiert in der obersten Zeile.

"_,o=+# *| )(x ^ &"alle enthalten die Frisuren mit 3 identischen Zeichen, aus denen wir die wählen ite Zeichen, j.

Wenn jes sich nicht um ein Leerzeichen handelt, gibt der folgende Ausdruck 3 Kopien des Zeichens zurück. Wenn es sich um ein Leerzeichen handelt, wählen wir die richtige Frisur aus %w{}. Die "ungeraden" Frisuren haben die Nummern 6,9,13,14,15,16,18,19 und i%11-2geben einen perfekten Hash dazu0..7

j<?!?%w{@__ ((_ >X< '*` -*~*- )|( \|/ _/7}[i%11-2]:j*3

Alles, was bleibt, ist, 14 Felder (zentriert) aufzufüllen und eine angemessene Anzahl von Mitten / Böden zu drucken.

Python 2 , 204 Bytes

i=input();l=len(i)
for l in[' '*4+' -'[x==6]+"_,o=+#**|_)(x@(>'^)\\&_,o=+#~*|/)(x_(X*^||&_,o=+#**|7)(x__<`^(/&"[x::21]+' -'[x==6]+' '*5for x in i],['    (o o)     ']*l,['ooO--(_)--Ooo-']*l:print''.join(l)

Probieren Sie es online!

Java 8, 273 263 Bytes

a->{String r[]={"","",""},s="    ",t="ooO--(_)--Ooo",u="(o o)";for(int i:a){r[0]+=s+(i==7?"-":" ")+"___,,,ooo===+++###*~****|||_/7)))(((xxx@__((_>X<'*`^^^)|(\\|/&&&".split("(?<=\\G...)")[i]+(i==7?"-":" ")+s+" ";r[1]+=s+u+s+" ";r[2]+=t+"-";}return t.join("\n",r);}

Probieren Sie es online aus.

Erläuterung:

a->{                       // Method with integer-array parameter and String return-type
  String r[]={"","",""},   //  Result-String, starting at three empty rows
         s="    ",         //  Temp-String of four spaces for the first and second rows
         t="ooO--(_)--Ooo",//  Temp-String for the third row
         u="(o o)";        //  Temp-String for the second row
  for(int i:a){            //  Loop over the input-array
    r[0]+=                 //   Append to the first row:
          s                //    Four spaces
          +(i==7?          //    If the number is 7 (edge-case):
             "-"           //     Append "-"
            :              //    Else:
             " ")          //     Append a single space
          +"___,,,ooo===+++###*~****|||_/7)))(((xxx@__((_>X<'*`^^^)|(\\|/&&&".split("(?<=\\G...)")[i]
                           //    Append the correct hat based on `i`
          +(i==7?"-":" ")  //    If the number is 7, append "-" again, else a space
          +s+" ";          //    And append five spaces
    r[1]+=                 //   Append to the second row:
          s                //    Four spaces
          +u               //    The head
          +s+" ";          //    Five spaces
    r[2]+=                 //   Append to the third row:
          t                //    The hands and bodies
          +"-";}           //    And the stitch "-"
  return t.join("\n",r);}  //  Return the three rows as single newline delimited String

R , 247 242 Bytes

function(a,n=length(a)){for(i in a)cat(format(h[i],,,,"c",14+!20-i))
cat("
","   (o o)     "*n,"
")
cat("ooO--(_)--Ooo"*n,sep="-")}
"*"=rep
h=readLines(,21)
___
,,,
ooo
===
+++
###
-*~*-
***
|||
_/7
)))
(((
xxx
@__
((_
>X<
'*`
^^^
)|(
\|/
&&&

Probieren Sie es online!

Versuchen Sie nun, R auf eine handlichere Byteanzahl zu bringen ...

Da das Ausführen von Zeichenmanipulationen in R so hoffnungslos ausführlich ist, habe ich mich darauf festgelegt, alle Gesichts- und Frisurenmuster so aufzulisten, wie sie sind. Zum hübschen Drucken der Frisuren benutze ich die formatFunktion mit justify="centre". Leider müssen wir ein zusätzliches Auffüllzeichen verwenden, i==20da formatdas Auffüllen so berechnet wird, als ob der Backslash maskiert wäre \\|/.

Die aktuelle Version verwendet keinen nachgestellten Bindestrich.

Edit: Gutschrift an JayCe für -2 und Giuseppe für -3 Bytes.

C! ( C-Wow 1.1.0), 251 Bytes

(Erfordert die Übergabe von Argumenten bei der Programmausführung, durch Leerzeichen getrennt)

SS("     (o o)     \nooO--(_)--Ooo-",'\n') SS("___A,,,AoooA===A+++A###A-*~*-A***A|||A_/7A)))A(((AxxxA@__A((_A>X<A'*`A^^^A)|(A\\|/A&&&",'A') F(MR("0",A(0),"23"),W("?");E) I(AC,W("     ");RI(TN(A(i))+2);W("     ")); WL I(AC,W(RI(0))); WL I(AC,W(RI(1)));

Ungolfed-Version:

STRSPLIT("     (o o)     \nooO--(_)--Ooo-", '\n')
STRSPLIT("___A,,,AoooA===A+++A###A-*~*-A***A|||A_/7A)))A(((AxxxA@__A((_A>X<A'*`A^^^A)|(A\\|/A&&&", 'A')
IF(MATHRANGE("0", ARGS(0), "23"), PRINT("?"); E)
LOOP(ARGC, PRINT("     "); READI(TONUM(ARGS(i)) + 2); PRINT("     "));
PRINTL
LOOP(ARGC, PRINT(READI(0)));
PRINTL
LOOP(ARGC, PRINT(READI(1)));

Rot , 333 319 Bytes

func[x][h: copy[]i: 0
foreach[k l m]{___,,,ooo===+++###   ***|||_/7)))(((xxx@__((_>X<'*`^^^^^^)|(\|/&&&}[alter h
pad pad/left either 7 = i: i + 1["-*~*-"][rejoin[" "k l m" "]]9
14]foreach y x[prin h/(y)]print append/dup copy"^/"{    (o o)     }l: length? x
print take/part append/dup copy""{ooO--(_)--Ooo-}l 14 * l - 1]

Probieren Sie es online!

Rubin , 163 Bytes

->a{puts a.map{|i|(i==6?"-*~*-":i<9?"_,o=+#~*|"[i]*3:"_/7)))(((xxx@__((_>X<'*`^^^)|(\\|/&&&"[3*i-27,3]).center 14}*"","    (o o)     "*k=a.size,"ooO--(_)--Ooo-"*k}

Probieren Sie es online!

0-indiziert. Ich spielte mit der Antwort von Level River St und fand einen anderen Ansatz, um die Frisuren zu verschlüsseln, anscheinend von ähnlicher Golfiness. Hier behandeln wir den "längsten" 5-Zeichen-Haarschnitt als Sonderfall, triviale Muster im ersten Teil der Liste werden mit je 1 Zeichen codiert, und im zweiten Teil werden alle 3-Zeichen-Muster wörtlich aufgelistet, egal - sind diese Zeichen verschieden oder nicht. Endlich kommt das Affengesicht-Kochfeld.

C (GCC) , 210 212 Bytes

-4 Bytes dank Ceilingcat . (Es ist wieder gewachsen, als ich einen Fehler behoben habe, den der ursprüngliche Code hatte.)

Ziemlich einfach.

#define r(s)for(i=!puts("");i<n;printf(s,c,"___,,,ooo===+++###*~****|||_/7)))(((xxx@__((_>X<'*`^^^)|(\\|/&&&"+x*3,c=x^6?32:45,x=l[i++]));
x,c,i;f(l,n)int*l;{r("%5c%.3s%-6c")r("    (o o)     ")r("ooO--(_)--Ooo-")}

Probieren Sie es online!

PowerShell , 187 171 Byte

^{-16 Bytes dank mazzy}

''+($args|%{($x=' '*4)+($y=' -'[$_-eq6])+("___,,,ooo===+++###*~****|||_/7)))(((xxx@__((_>X<'*``^^^)|(\|/&&&"|% s*g($_*3)3)+$y+$x;$z++})
"$x(o o)$x "*$z
"ooO--(_)--Ooo-"*$z

Probieren Sie es online!

0-indiziert, hat einen nachgestellten Bindestrich.

Abgerollt:

''+($args|%{
    ($x=' '*4) + ($y=' -'[$_-eq6]) + 
    ("___,,,ooo===+++###*~****|||_/7)))(((xxx@__((_>X<'*``^^^)|(\|/&&&"|% substring ($_*3) 3) +
    "$y$x ";
    $z++
    })
"$x(o o) $x"*$z
"ooO--(_)--Ooo-"*$z

Nichts Besonderes. Nur die erste Zeile enthält eine anständige Logik. Es indiziert die Haarschnur mit $current_entry_value*3und sschöpft den Teil mit Ubstrin aus g, bevor alle Teile zu einer großen Linie zusammengefasst werden. Stieß auf das Problem, dem nächsten Caret zu entkommen, und fragte mich, warum ich einen IndexOutOfBounds-Fehler bekam, der jedoch behoben wurde. Verwenden Sie jetzt eine viel bessere Methode, um die erste Zeile zu kombinieren.

195 Bytes, um der Angabe ohne führende / nachfolgende Bindestriche zu folgen

Python 3 , 240 Bytes

h=[x*3for x in"_,o=+#*|)(x^&"]
for i,*l in(6,"-*~*-"),(9,"_/7"),(13,"@__","((_",">X<","'*`"),(18,")|(","\|/"):h[:i]+=l
*x,=map(int,input().split())
l=len(x)
p=print
p(*(h[i].center(13)for i in x))
p("    (o o)     "*l)
p("ooO--(_)--Ooo-"*l)

Probieren Sie es online!

Runenverzauberungen , 313 Bytes

B6?>8b2*B0il2)?\B" "9a2*
{" ___ "D
{" ,,, "D
{" ooo "D
{" === "D
{" +++ "D
{" ### "D
{"-*~*-"D
{" *** "D
{" ||| "D
{" _/7 "D
{" ))) "D
{" ((( "D
{" xxx "D
{" @__ "D
{" ((_ "D
{" >X< "D
{" '*` "D
{" ^^^ "D
{" )|( "D
{" \|/ "D\
{" &&& "D{
{"    " LLRB͍!{
"-(_)--Ooo-"{*@\~4-:l͍e,:{$ak$"    (o o)     "{*$ak$"ooO-"

Probieren Sie es online!

Ziemlich kompakt im Hinblick auf die Komprimierung der Zeichenfolgen und die Wiederverwendung von Segmenten, sofern möglich, sowie die Verwendung der Eingabewerte als direkte Sprungoffsets beim BRanching.

Wenn übermäßiger nachgestellter Speicherplatz zulässig ist, kann dieser durch Weglassen 4-der letzten Zeile um 2 Byte verkürzt werden . +2 Bytes für a, 1-wenn das Finale -nicht vorhanden sein soll (passende Spezifikation, verletzende Beispiele).

Es " (o o) "ist ärgerlich, dass der Chunk unmöglich komprimiert werden kann, da die Erstellung mit Dingen wie " "4*genau der gleichen Anzahl von Bytes endet.

Eingaben> 21 machen Spaß. ZB eine einzelne 22 sorgt für eine gründliche Rasur .