21 fryzur apokalipsy

Biorąc pod uwagę listę liczb od 1 do 21 (lub od 0 do 20), wyjmij „zszyty razem” rysunek następujących powierzchni ( patrz zasady dotyczące informacji o zszywaniu ):

     ___           ,,,           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-

Każda unikalna twarz wymieniona w nowym wierszu (# to identyfikator liczby całkowitej twarzy):

     ___      
    (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

Twarz jest następująca:

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

Gdzie hjest dynamiczna apokaliptyczna fryzura i Spotencjalny łącznik.

Przykłady

Wejście: [1,2,3,4,5]

Wynik:

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

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

Wynik:

     ___           ,,,           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-

Wejście: ["Fraggle Rock"] / [22]/ [-21041024]/[22,23,24,25,26]

Wynik: Nobody cares.

Wejście: [1,1,1,1]

Wynik:

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

Zasady

• Wcześniejsze i końcowe znaki nowej linii / spacje / łącznik są w porządku.
• Twarze mogą pojawiać się na wejściu więcej niż jeden raz.
• Jeśli na wejściu jest niepoprawna liczba, możesz mieć niezdefiniowane zachowanie.
• Szwy:
  • Zszyte ściany zostaną połączone pojedynczym łącznikiem w dolnej (trzeciej) linii.
  • Wszystkie twarze będą na jednej linii (w przeciwieństwie do pierwszego rysunku).
• Dane wejściowe mogą być indeksowane 0 lub 1, przy czym 20 oznacza maksimum dla 0, 21 dla 1.
• To jest golf golfowy , wygrana o najniższej liczbie bajtów.

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

1-indeksowany, z zawijaniem indeksu. Postępowałem zgodnie ze specyfikacją tutaj, która wymaga łącznika między ostatnią linią każdej twarzy, a nie przypadków testowych, które zawierają łącznik po ostatniej linii każdej twarzy.

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

Spróbuj

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

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]

Wypróbuj online!

Indeksowanie w oparciu o 0; nic szczególnie sprytnego tutaj, tylko dane dostępne poprzez krojenie i użycie exec zamiast pętli.

Węgiel drzewny , 103 102 bajtów

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

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

Ｅ²⪫Ｅθ

Zapętlić dwa razy wejście. Każdy wynik jest następnie domyślnie drukowany w osobnym wierszu.

⎇ι(o o)

W drugiej pętli po prostu wygeneruj oczy.

⪫ײ§ -⁼λ⁶

Zawiń fryzurę 6 cali - , inne fryzury w przestrzeni.

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

Wyodrębnij trzy znaki fryzury ze skompresowanego sznurka.

× ⁹

Wstaw dziewięć odstępów między włosami lub oczami.

Ｍ⁴←

Przesuń 4 pola w lewo.

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

Wydrukuj pozostałe twarze, połączone za pomocą -.

R , 413 391 bajtów

Dzięki Giuseppe za 22 bajty mniej i otrzymanie tego poniżej 400 bajtów.

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)]))}

Wypróbuj online!

JavaScript (ES6), 200 199 bajtów

Oczekuje 1-indeksowanych danych wejściowych.

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

Wypróbuj online!

Skomentował

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

Rubin , 164 bajty

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

Zero indeksowane. Wypróbuj online!

Wszystkie trudne rzeczy dzieją się w górnej linii.

"_,o=+# *| )(x ^ &"zawiera wszystkie fryzury z 3 identycznymi postaciami, z których wybieramy tę ipostać,j .

jeśli jnie jest spacją, poniższe wyrażenie zwraca 3 kopie znaku. Jeśli jest to spacja, wybieramy odpowiednią fryzurę pomiędzy %w{}. „Dziwne” fryzury mają numery 6,9,13,14,15,16,18,19 i i%11-2dają idealny hasz do0..7

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

Pozostało tylko wypełnienie 14 pól (na środku) i wydrukowanie odpowiedniej liczby środków / dna.

Python 2 , 204 bajty

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)

Wypróbuj online!

Java 8, 273 263 bajtów

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

Wypróbuj online.

Wyjaśnienie:

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

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<
'*`
^^^
)|(
\|/
&&&

Wypróbuj online!

Teraz próbuję doprowadzić R do łatwiejszej do zarządzania liczby bajtów ...

Ponieważ manipulowanie postaciami w R jest tak beznadziejnie gadatliwe, postanowiłem wymienić wszystkie wzory twarzy i fryzur w niezmienionej formie. Do ładnego drukowania fryzur, w których używam formatfunkcji justify="centre". Niestety, musimy użyć dodatkowego znaku wypełniania, i==20ponieważ formatoblicza wypełnienie tak, jakby ukośnik został pominięty, jak \\|/.

Obecna wersja nie używa łącznika końcowego.

Edycja: Podziękowania dla JayCe za -2 i Giuseppe za -3 bajty.

DO! ( C-Wow 1.1.0), 251 bajtów

(Wymaga przekazania argumentów podczas wykonywania programu, oddzielonych spacją)

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

Wersja bez golfa:

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

Czerwony , 333 319 bajtów

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]

Wypróbuj online!

Rubinowy , 163 bajty

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

Wypróbuj online!

0-indeksowane. I bawił się poziom rzeki st za odpowiedź i znaleźć inne podejście do zakodowania fryzury, pozornie podobnej golfiness. Tutaj traktujemy „najdłuższą” fryzurę 5-znakową jako szczególny przypadek, trywialne wzory w pierwszej części listy są kodowane przez 1 znak, a w drugiej części wszystkie wzory 3-znakowe są wymienione dosłownie, bez względu na to - czy te znaki są odrębne czy nie. Wreszcie pojawia się płyta kotła o małpiej twarzy.

C (gcc) , 210 212 bajtów

-4 bajty dzięki ceilingcat . (Rozrósł się ponownie, gdy naprawiłem błąd, który miał oryginalny kod).

Całkiem proste.

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

Wypróbuj online!

PowerShell , 187 171 bajtów

^{-16 bajtów dzięki 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

Wypróbuj online!

Indeksowane 0, ma łącznik końcowy.

Rozwinięty:

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

Nic nadzwyczajnego. Tylko pierwsza linia ma porządną logikę. Indeksuje się w sznurku włosów za pomocą $current_entry_value*3i sczerpie ten kawałek za pomocą ubstring , przed połączeniem wszystkich kawałków w jedną dużą linię. Natknąłem się na problem `` ucieczki przed następnym karetką, pozostawiając mnie zastanawiającego się, dlaczego dostaję błąd IndexOutOfBounds, ale to naprawiono. Teraz używam znacznie lepszego sposobu na połączenie pierwszej linii.

195 bajtów, aby postępować zgodnie ze specyfikacją bez myślników początkowych / końcowych

Python 3 , 240 bajtów

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)

Wypróbuj online!

Runiczne Zaklęcia , 313 bajtów

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

Wypróbuj online!

Racjonalnie kompaktowy pod względem kompresji ciągów znaków i ponownego wykorzystywania segmentów tam, gdzie to możliwe, a także wykorzystywania wartości wejściowych jako bezpośrednich przesunięć skoku, gdy B ranczowania.

Jeśli dozwolone jest nadmiarowe końcowe miejsce, można je skrócić o 2 bajty, pomijając znak 4-w ostatnim wierszu. +2 bajty, 1-jeśli -nie ma tam finału (dopasowanie specyfikacji, naruszenie przykładów).

Kawał, " (o o) " jest denerwujący, niemożliwy do skompresowania, ponieważ konstruowanie go przy użyciu takich rzeczy" "4* kończy się dokładnie taką samą liczbą bajtów.

Przekazywanie danych wejściowych> 21 robi fajne rzeczy. Np. Pojedynczy 22 daje dokładne golenie .