Los 21 peinados del apocalipsis

16

Los 21 peinados del apocalipsis

Dada una lista de números entre 1 y 21 (o 0 y 20) genera un dibujo "cosido" de las siguientes caras ( consulte las reglas para la información de costura ):

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

Cada cara única listada en una nueva línea (el # es la ID entera de la cara):

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

La cara es la siguiente:

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

¿Dónde hestá el peinado dinámico apocalíptico y Ses el guión de costura potencial?

Ejemplos

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

Salida:

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

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

Salida:

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

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

Salida: Nobody cares.

Entrada: [1,1,1,1]

Salida:

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

Reglas

  • Las líneas / espacios / guiones anteriores y posteriores están bien.
  • Las caras pueden aparecer más de una vez en la entrada.
  • Si hay un número no válido en la entrada, puede tener un comportamiento indefinido.
  • La costura:
    • Las caras cosidas se concatenarán con un solo guión en la línea inferior (tercera).
    • Todas las caras estarán en una sola línea (a diferencia del primer dibujo).
  • La entrada puede ser 0 o 1 indexada, siendo 20 el máximo para 0, 21 para 1.
  • Este es el código de golf , el menor recuento de bytes gana.
code-golf  ascii-art 
— Urna de pulpo mágico
fuente
1
— NinjaBearMonkey
77
El número 7 parece violar la parte de "la cara es la siguiente"
— boboquack
10
Todos sus casos de prueba incluyen un guión de "costura" al final, que parece contradecir la especificación.
— Shaggy
3
Kilroy estuvo aquí.
— msh210
2
@MagicOctupusUrn, ¿puede abordar el problema de los guiones finales que planteé anteriormente?
— Shaggy

Respuestas:

9

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

1 indexado, con ajuste de índice. He seguido la especificación aquí, que requiere un guión entre la última línea de cada cara, en lugar de los casos de prueba, que incluyen un guión después de la última línea de cada cara.

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

Intentalo

[                                             :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
— Lanudo
fuente
1
Buen trabajo para llegar a 100. Ese método char-mirror que hemos querido realmente sería útil aquí.
— Oliver
Además, esa envoltura &para aprovechar m³era genial. Especialmente porque eso lo hizo basado en 1.
— Oliver
Era al revés; Me di cuenta de que podía moverlo &allí si lo hacía basado en 1;) Todavía siento que hay más para jugar golf aquí, pero es tarde, así que tendrá que esperar hasta mañana.
— Shaggy
6

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]

Pruébalo en línea!

Indexación basada en 0; Aquí no hay nada especialmente inteligente, solo datos a los que se accede mediante el corte y el uso de exec en lugar de un bucle.

— Chas Brown
fuente
— Lynn
6

Carbón , 103102 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｅ²⪫Ｅθ

Pase sobre la entrada dos veces. Cada resultado se imprime implícitamente en su propia línea.

⎇ι(o o)

En el segundo bucle, solo genera los ojos.

⪫ײ§ -⁼λ⁶

Envuelva el peinado 6 en - s, otros peinados en espacios.

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

Extrae los tres personajes de peinado de una cadena comprimida.

× ⁹

Inserte nueve espacios entre cada cabello u ojos.

Ｍ⁴←

Mueve 4 espacios a la izquierda.

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

Imprime el resto de las caras, unidas con una -.

— Neil
fuente
6

R , 413 391 bytes

Gracias Giuseppe por 22 bytes menos y obteniendo esto por debajo de 400 bytes. 

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

Pruébalo en línea!

— JayCe
fuente
probablemente deberías alias utf8ToIntyintToUtf8
— Giuseppe
— Giuseppe
@Giuseppe buen punto! Me avergüenzo de mis intercambios de índices porque es tan costoso. Voy a trabajar en él.
— JayCe
@JayCe Te perdiste uno más reppara acortar:for(i in s)K(I(c(rep<--
— Kirill L.
Gracias @ KirillL. ! Me aseguraré de incluir esto cuando finalmente tenga tiempo de revisar este código.
— JayCe
5

JavaScript (ES6), 200 199 bytes

Espera 1 entrada indexada.

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

Pruébalo en línea!

Comentado

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
fuente
4

Rubí , 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}

Cero indexado. Pruébalo en línea!

Todo lo difícil sucede en la línea superior.

"_,o=+# *| )(x ^ &" contiene todos los peinados con 3 caracteres idénticos, de los cuales seleccionamos el i carácter th,j .

si jno es un espacio, la siguiente expresión devuelve 3 copias del carácter. Si es un espacio, seleccionamos el peinado correcto entre %w{}. Los peinados "extraños" son los números 6,9,13,14,15,16,18,19 y i%11-2dan un hash perfecto para0..7

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

Todo lo que queda es rellenar hasta 14 espacios (centrados) e imprimir un número apropiado de medios / fondos.

— Level River St
fuente
Puede colocar paréntesis encenter(14)
— Kirill L.
2

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)

Pruébalo en línea!

— ovs
fuente
2

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

Pruébalo en línea.

Explicación:

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
fuente
2

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

Pruébalo en línea!

Ahora, tratando de llevar a R a un recuento de bytes más manejable ...

Dado que hacer manipulaciones de personajes en R es tan irremediablemente detallado, decidí enumerar todos los patrones de cara y peinado completamente tal como están. Para imprimir bonitos los peinados con los que uso la formatfunción justify="centre". Desafortunadamente, necesitamos usar un carácter de relleno adicional i==20porque formatcalcula el relleno como si se hubiera escapado la barra invertida, como\\|/ .

La versión actual no utiliza guiones finales.

Editar: crédito a JayCe por -2 y Giuseppe por -3 bytes.

— Kirill L.
fuente
Me encanta tu enfoque directo! No sabía justify="centre"que probablemente pueda reutilizarlo. Menos dos caracteres :"/"=rep
— JayCe
otros dos bytes hacia abajo:format(h[i],,,,"c",14+!20-i)
— Giuseppe
@Giuseppe es en realidad -3, así que aún mejor. @JayCe es muy agradable, de hecho, tampoco usamos la multiplicación, por lo que anular se *ve aún mejor, ¡ahora se parece a una string * numberoperación común a muchos otros idiomas!
— Kirill L.
2

¡C! ( C-Wow 1.1.0), 251 bytes

(Requiere que se pasen los argumentos sobre la ejecución del programa, separados por espacios)

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

Versión sin golf:

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
fuente
1

Rojo , 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]

Pruébalo en línea!

— Galen Ivanov
fuente
1

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

Pruébalo en línea!

0 indexado. Jugueteé con la respuesta de Level River St y encontré otro enfoque para codificar los peinados, aparentemente de golfiness similar. Aquí, tratamos el corte de pelo "más largo" de 5 caracteres como un caso especial, los patrones triviales en la primera parte de la lista están codificados por 1 carácter cada uno, y en la segunda parte todos los patrones de 3 caracteres se enumeran literalmente, no importa: son esos caracteres distintos o no. Finalmente llega la repetitiva cara de mono.

— Kirill L.
fuente
1

C (gcc) , 210 212 bytes

-4 bytes gracias a ceilingcat . (Creció nuevamente cuando solucioné un error que tenía el código original).

Muy claro.

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

Pruébalo en línea!

— gastropner
fuente
— ceilingcat
1

PowerShell , 187 171 bytes

-16 bytes gracias a 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

Pruébalo en línea!

Indizado con 0, tiene un guión final.

Desenrollado:

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

Nada muy elegante. Solo la primera línea tiene cierta lógica decente. Se indexa en la cuerda del cabello usando $current_entry_value*3y saca esa porción usando substrin g, antes de unir todas las porciones en una sola línea. Me encontré con el problema de `escapar del siguiente problema, dejándome preguntándome por qué recibía un error de IndexOutOfBounds, pero eso se solucionó. Ahora usando una forma mucho mejor para combinar la primera línea.

195 bytes para seguir la especificación de no guiones iniciales / finales

— Veskah
fuente
1
nice 7. podrías guardar algunos bytes ¡ Pruébalo en línea!
— mazzy
1
y algo más ¡ Pruébelo en línea!
— mazzy
1

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)

Pruébalo en línea!

— Daniil Tutubalin
fuente
0

Encantamientos rúnicos , 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-"

Pruébalo en línea!

Razonablemente compacto en términos de comprimir las cadenas y reutilizar segmentos cuando sea posible, así como usar los valores de entrada como compensaciones de salto directo cuando B ranchear.

Si se permite un exceso de espacio final, esto puede acortarse en 2 bytes omitiendo el 4-en la última línea. +2 bytes para un 1-si el final- está destinada (especificación coincidente, violando ejemplos).

El trozo " (o o) "es molesto, imposible de comprimir, ya que construirlo usando cosas como" "4* termina siendo exactamente el mismo número de bytes.

Pasar entradas> 21 hacen cosas divertidas. Por ejemplo, un solo 22 da un afeitado apurado .

— Draco18s ya no confía en SE
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.