Les 21 coiffures de l'Apocalypse

16

Les 21 coiffures de l'Apocalypse

Étant donné une liste de nombres entre 1 et 21 (ou 0 et 20), sortez un dessin "cousu ensemble" des faces suivantes ( voir les règles pour les informations de couture ):

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

Chaque visage unique répertorié sur une nouvelle ligne (le # est l'ID entier du visage):

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

Le visage est le suivant:

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

Où se htrouve la coiffure apocalyptique dynamique et Sle trait d'union de couture potentiel.

Exemples

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

Production:

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

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

Production:

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

Entrée: ["Fraggle Rock"] / [22]/ [-21041024]/[22,23,24,25,26]

Production: Nobody cares.

Contribution: [1,1,1,1]

Production:

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

Règles

  • Les sauts de ligne / espaces / tirets précédents et finaux sont corrects.
  • Les visages peuvent apparaître plusieurs fois dans l'entrée.
  • S'il y a un nombre non valide dans l'entrée, vous pouvez avoir un comportement indéfini.
  • La couture:
    • Les faces cousues seront concaténées par un seul tiret sur la ligne du bas (3e).
    • Les faces seront toutes sur une seule ligne (contrairement au premier dessin).
  • L'entrée peut être indexée 0 ou 1, 20 étant le maximum pour 0, 21 pour 1.
  • Il s'agit du code-golf , le plus petit nombre de victoires d'octets.
code-golf  ascii-art 
— Urne de poulpe magique
source
1
— NinjaBearMonkey
7
Le numéro 7 semble violer la partie "le visage est comme suit"
— boboquack
10
Tous vos cas de test incluent un tiret de "couture" de fin, qui semble contredire la spécification.
— Shaggy
3
Kilroy était ici.
— msh210
2
@MagicOctupusUrn, pouvez-vous s'il vous plaît aborder le problème des tirets de fin que j'ai soulevé ci-dessus?
— Shaggy

Réponses:

9

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

1 indexé, avec habillage d'index. J'ai suivi la spécification ici, qui nécessite un trait d'union entre la dernière ligne de chaque face, plutôt que les cas de test, qui incluent un trait d'union après la dernière ligne de chaque face.

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

Essayez-le

[                                             :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
— Hirsute
source
1
Beau travail pour arriver à 100. Cette méthode de miroir de char que nous voulions serait vraiment utile ici.
— Oliver
De plus, cet emballage du &pour en profiter m³était génial. D'autant plus que cela le rendait basé sur 1.
— Oliver
C'était l'inverse; Je me suis rendu compte que je pourrais déplacer le &là - bas si je le faisais à base de 1;) Je sens toujours qu'il y a plus à jouer au golf ici, mais il est tard, donc il faudra attendre jusqu'à demain.
— Shaggy
6

Python 2 , 209 octets

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]

Essayez-le en ligne!

Indexation basée sur 0; rien de particulièrement intelligent ici, juste des données accessibles via le découpage et en utilisant exec au lieu d'une boucle.

— Chas Brown
source
— Lynn
6

Fusain , 103 102 octets

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

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

Ｅ²⪫Ｅθ

Faites une boucle sur l'entrée deux fois. Chaque résultat est ensuite implicitement imprimé sur sa propre ligne.

⎇ι(o o)

Sur la deuxième boucle, il suffit de générer les yeux.

⪫ײ§ -⁼λ⁶

Enveloppez la coiffure 6 en -s, d'autres coiffures dans les espaces.

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

Extrayez les trois caractères de coiffure d'une chaîne compressée.

× ⁹

Insérez neuf espaces entre chaque cheveux ou yeux.

Ｍ⁴←

Déplacez 4 espaces vers la gauche.

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

Imprimez le reste des visages, joint avec un -.

— Neil
source
6

R , 413 391 octets

Merci Giuseppe pour 22 octets de moins et pour avoir moins de 400 octets. 

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

Essayez-le en ligne!

— JayCe
source
vous devriez probablement alias utf8ToIntetintToUtf8
— Giuseppe
— Giuseppe
@Giuseppe bon point! J'ai honte de mes swaps d'indices, c'est tellement coûteux. J'y travaillerai.
— JayCe
@JayCe Vous en avez manqué une de plus reppour raccourcir:for(i in s)K(I(c(rep<--
— Kirill L.
Merci @KirillL. ! Je m'assurerai de l'inclure lorsque j'aurai enfin le temps de revoir ce code.
— JayCe
5

JavaScript (ES6), 200 199 octets

Attend une entrée indexée 1.

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

Essayez-le en ligne!

Commenté

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
— Arnauld
source
4

Rubis , 164 octets

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

Zéro indexé. Essayez-le en ligne!

Toutes les choses difficiles se produisent sur la ligne supérieure.

"_,o=+# *| )(x ^ &"contient toutes les coiffures avec 3 personnages identiques, dont nous sélectionnons le ie caractère, j.

s'il jne s'agit pas d'un espace, l'expression suivante renvoie 3 copies du caractère. S'il s'agit d'un espace, nous sélectionnons la coiffure correcte parmi les %w{}. Les coiffures "bizarres" sont les numéros 6,9,13,14,15,16,18,19 et i%11-2donnent un hachage parfait à0..7

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

Il ne reste plus qu'à remplir 14 espaces (centrés) et à imprimer un nombre approprié de middles / bas.

— Level River St
source
Vous pouvez déposer des parenthèsescenter(14)
— Kirill L.
2

Python 2 , 204 octets

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)

Essayez-le en ligne!

— ovs
source
2

Java 8, 273 263 octets

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

Essayez-le en ligne.

Explication:

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
— Kevin Cruijssen
source
2

R , 247 242 octets

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

Essayez-le en ligne!

Maintenant, essayer d'amener R à un nombre d'octets plus gérable ...

Étant donné que les manipulations de personnages dans R sont si désespérément verbeuses, je me suis décidé à répertorier tous les modèles de visage et de coiffure tels quels. Pour une jolie impression des coiffures formatavec lesquelles j'utilise la fonction justify="centre". Malheureusement, nous devons utiliser un caractère de remplissage supplémentaire pour i==20car formatcalcule le remplissage comme si la barre oblique inverse avait été échappée, comme\\|/ .

La version actuelle ne pas de trait d'union de fin.

Edit: Crédit à JayCe pour -2 et Giuseppe pour -3 octets.

— Kirill L.
source
Aimez votre approche directe! Je ne savais pas que justify="centre"je pouvais probablement le réutiliser. Moins deux caractères :"/"=rep
— JayCe
encore deux octets de moins:format(h[i],,,,"c",14+!20-i)
— Giuseppe
@Giuseppe c'est en fait -3, donc encore mieux. @JayCe très sympa, en fait nous n'utilisons pas non plus la multiplication, donc prioritaire* est encore meilleure - elle ressemble maintenant à une string * numberopération commune à de nombreuses autres langues!
— Kirill L.
2

C! ( C-Wow 1.1.0), 251 octets

(Nécessite des arguments à transmettre lors de l'exécution du programme, séparés par des espaces)

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

Version non golfée:

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)));
— 0x22fe
source
1

Rouge , 333 319 octets

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]

Essayez-le en ligne!

— Galen Ivanov
source
1

Rubis , 163 octets

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

Essayez-le en ligne!

0 indexé. J'ai tripoté la réponse de Level River St et j'ai trouvé une autre approche pour encoder les coiffures, apparemment d'un golfeur similaire. Ici, nous traitons la coupe de cheveux 5 caractères "la plus longue" comme un cas spécial, les modèles triviaux dans la première partie de la liste sont codés par 1 caractère chacun, et dans la deuxième partie, tous les modèles 3 caractères sont répertoriés littéralement, peu importe - ces caractères sont-ils distincts ou non? Vient enfin le passe-partout à face de singe.

— Kirill L.
source
1

C (gcc) , 210 212 octets

-4 octets grâce à plafond . (Il a de nouveau augmenté lorsque j'ai corrigé un bogue du code d'origine.)

Assez simple.

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

Essayez-le en ligne!

— gastropner
source
— plafondcat
1

PowerShell , 187 171 octets

-16 octets grâce à 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

Essayez-le en ligne!

Indexé 0, a un trait d'union de fin.

Déroulé:

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

Rien d'extraordinaire. Seule la première ligne contient une logique décente. Il indexe dans la chaîne de cheveux en utilisant le $current_entry_value*3et écope ce morceau en utilisant substring , avant de joindre tous les morceaux en une seule grande ligne. Ran dans la question de `échapper au caret suivant, me laissant me demander pourquoi j'obtenais une erreur IndexOutOfBounds mais c'est corrigé. Maintenant, en utilisant une bien meilleure façon de combiner la première ligne.

195 octets pour suivre la spécification sans trait d'union / tiret

— Veskah
source
1
nice 7. vous pourriez économiser quelques octets Essayez-le en ligne!
— mazzy
1
et encore plus Essayez-le en ligne!
— mazzy
1

Python 3 , 240 octets

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)

Essayez-le en ligne!

— Daniil Tutubalin
source
0

Enchantements runiques , 313 octets

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

Essayez-le en ligne!

Raisonnablement compact en termes de compression des chaînes et de réutilisation des segments dans la mesure du possible, ainsi que d'utilisation des valeurs d'entrée comme sauts directs lorsque B élevage ranch.

Si un espace de fin excessif est autorisé, celui-ci peut être raccourci de 2 octets en omettant le 4-sur la dernière ligne. +2 octets pour un1- si la finale -est destinée à ne pas être là (spécification correspondante, exemples violés).

Le morceau, " (o o) " est ennuyeux, impossible à compresser, car le construire en utilisant des choses comme" "4* finit par avoir exactement le même nombre d'octets.

Passer des entrées> 21 fait des choses amusantes. Par exemple, un seul 22 donne un rasage de près .

— Draco18s ne fait plus confiance à SE
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.