Quack the Angry Duck

56

Nadie está seguro de lo que >:Upretende representar el emoticón , pero muchos estudiosos creen que parece un pato enojado . Asumamos que ese es el caso.

Tarea

Dado un número entero n entre 0 y 3 inclusive, imprimir o devolver

quack

si n = 0,

>:U

si n = 1,

     U   U
>  : U   U
 >   U   U
>  : U   U
      UUU

si n = 2, o

                  >:U         >:U
>:U               >:U         >:U
   >:U       >:U  >:U         >:U
      >:U         >:U         >:U
         >:U      >:U         >:U
      >:U         >:U         >:U
   >:U       >:U  >:U         >:U
>:U               >:U         >:U
                     >:U>:U>:U

si n = 3.

Puede suponer que la entrada siempre será válida. No debe haber espacio inicial en la salida, pero cualquier cantidad de espacio final está bien. Los patos (con la posible excepción de @cobaltduck) no tienen tolerancia para las lagunas. El código más corto en bytes gana.

Alex A.
fuente
90
Primero estaba pensando "¿Qué es un pato?". Afortunadamente, ha proporcionado un enlace a la página de Wikipedia.
Adnan
66
"Los patos no toleran las lagunas". Pero eres un pájaro, no un pato, ¿eso significa que podemos usar lagunas? : P
Downgoat
66
@Downgoat Nope. Además, esa edición era completamente innecesaria, así que la revertí.
Alex A.
66
@Downgoat s /: P />: U /
ETHproductions
77
"Los patos no toleran las lagunas". Eso, mi amigo, es un estereotipo peligroso. Si no supiera sus intenciones, podría ofenderme.
cobaltduck

Respuestas:

19

CJam, 108 90 85 bytes

"quack"">:U":D"scT¦{$ì"{269b22bSf*D}:F~[ZYB].*s.+s5/"ÿ3nÜïS{JÐø¦yûn"F*33/z]ri=zN*

Tenga en cuenta que algunos caracteres no se pueden imprimir. Pruébalo en línea!

Antecedentes

Las dos primeras salidas son incompresibles en CJam.

Comprimir la última salida es sencillo. Después de eliminar todos los avances de línea, podemos dividir la cadena resultante en las ocurrencias de >:U, y calcular la longitud de cada cadena de espacios resultante.

Eso da como resultado la matriz

[18 9 0 15 9 3 7 2 9 6 9 9 9 6 9 6 9 9 3 7 2 9 0 15 9 21 0 0 0]

que podemos almacenar de manera eficiente al convertirlo de la base 22 a la base 269, produciendo los dígitos

[255 12 51 110 220 239 83 123 74 208 248 166 121 251 110 17]

Como cada dígito es menor que 256 , podemos almacenarlo como un solo byte.

Finalmente, comprimir la tercera salida se vuelve más fácil si transponemos líneas y columnas:

 > > 
  >  

 : : 

UUUU 
    U
    U
    U
UUUU

Contando una vez más los espacios entre caracteres que no son espacios en blanco, obtenemos la matriz

[1 1 3 8 1 6 0 0 0 5 4 4 0 0 0 0 0]

que se convierte

[115 159 99 84 166 123 36 236 6]

cuando se transcodifica desde la base 22 a la base 269.

Cómo funciona

"quack"   e# Push the first output.

">:U":D   e# Push the second output, and save it in D.

e# Push [115 159 99 84 166 123 36 236 6] as bytes.

"scT¦{$ì"

{         e# Define a code block:
  269b22b e#   Transcode from base 269 to base 22.
  Sf*     e#   Replace each digit with a string of that many spaces.
  D       e#   Push D.
}         e#
:F~       e# Save the block in F. Execute it.
[ZYB]     e# Push [3 2 11].
.*        e# Vectorized repeat; push [">>>" "::" "UUUUUUUUUUU"].
s         e# Flatten the array of strings.
.+        e# Append the nth character to the nth string of spaces.
s5/       e# Flatten and split into chunks of length 5.

e# Push [255 12 51 110 220 239 83 123 74 208 248 166 121 251 110 17] as bytes.

"ÿ3nÜïS{JÐø¦yûn"

F         e# Execute F.
*         e# Join the resulting array of strings of spaces, separating by ">:U".
33/       e# Split into chunks of length 33.
z         e# Zip; transpose rows with columns.

]         e# Wrap the entire stack in an array.
ri        e# Read a token from STDIN and interpret it as an integer.
=         e# Retrieve the element at the corresponding index.
z         e# Zip; transpose rows with columns or map "string" to ["string"].
N*        e# Join, separating by linefeeds.
Dennis
fuente
2
Me gusta el extra :Dentre las dos cuerdas.
Zgarb
77
@Zgarb Ha aplacado al gran señor del pato. El pato ahora sonríe.
Alex A.
77
Pasé la página pensando: "172 ... 162 ... 182 ... puedo vencer a todos esos. Espera, 90? Oh, es Dennis el Invencible ..."
ETHproductions
22

Java, 303 286 bytes

¡Ahorró 17 bytes gracias a @VoteToClose!

En realidad no pretende ser el más corto, solo pensé que sería divertido intentarlo en Java.

Crea una lista de variables de cadena que representan cadenas comunes, luego crea una matriz de todas las salidas, luego imprime la correcta.

String a(int y){String n="\n",d=">:U",A=" ",B=A+A,C=B+B,D=C+C,a="U"+B+" U"+n,G=D+A,H=C+B,c=d+G+d+n,E=B+A,F=C+E;String[]z={"quack",d,C+A+a+">"+B+": "+a+" >"+E+a+">"+B+": "+a+C+B+"UUU",D+D+B+c+d+D+F+c+B+A+d+F+d+B+c+H+d+G+c+G+d+H+c+H+d+G+c+E+d+F+d+B+c+d+D+F+c+D+D+C+A+d+d+d};return z[y];}

Sin golf:

String a(int y) {
    String n = "\n", d = ">:U", A = " ", B = A + A, C = B + B, D = C + C,
            a = "U" + B + " U" + n, G = D + A, H = C + B, c = d + G + d + n,
            E = B + A, F = C + E;
    String[] z = { "quack", d, C + A + a + ">" + B + ": " + a + " >" + E + a + ">" + B + ": " + a + C + B + "UUU", D + D + B + c + d + D + F + c + B + A + d + F + d + B + c + H + d + G + c + G + d + H + c + H + d + G + c + E + d + F + d + B + c + d + D + F + c + D + D + C + A + d + d + d };
    return z[y];
}

Esta es mi primera respuesta en este sitio, así que dígame si he hecho algo mal.

FlyingPiMonster
fuente
2
¡Se ve bien! Buen primer post, y bienvenidos a PPCG!
Conor O'Brien
@AlexA. Gracias por avisarme, lo arreglé.
FlyingPiMonster
2
@ kittycat3141 Se ve genial. ¡Buena solución y gracias por participar en mi desafío! :)
Alex A.
Parece que D+Ay C+Baparece con la suficiente frecuencia como para jugar más en 2 nuevas variables. También tengo la menor sensación de que usar una matriz con un bucle for podría ayudar, pero aún no he descubierto cómo ...
Addison Crump
9

05AB1E , 162 159 157 bytes

Código

Maldición, demasiado tiempo, pero al menos es algo:

">:U"VI3Qið16×7166b1ð:0Y:DUJ,Yð13×JD?X,3838b1ð:0Y:D?X,16255b1ð:0Y:D?X,16367b1ð:0Y:4F?X,}ð21×Y3×J,}¹2Qið4×" U   U"©J,">  :"®JD," >  "?®,,ð6×'U3×J,}¹iY,}"quack

Pruébalo en línea!


Explicación

La primera parte del código existe ">:U"V, que se establece Yen esa cadena. Después de eso, solo verificamos si la entrada es igual a 3. Eso se hace en la I3Qiparte. Si es igual, imprimimos la urraca gigante:

N = 3

Primero comienza con lo ð16×que simplemente empuja 16 caracteres espaciales. Después de eso, hay un número 7166b. Esto cubre la ">:U "parte, con un poco de ayuda de Retina :). Usé este script para convertir la cadena a un número binario. Después de eso, llegamos a la 1ð:0Y:parte, que reemplaza cada 1con un carácter de espacio y cada 0con Y, que se ha establecido en >:U. Después de eso, Dduplicamos esta cadena, la almacenamos Xusando Uy en Jla pila. Hacemos estallar usando ,, que imprime la cadena completa con una nueva línea. Todos los demás después de eso se basan en el mismo principe. La declaración if termina en el segundo }.

La conversión completa se puede encontrar aquí .

N = 2

Ahora verificamos si la entrada es igual a 2. Esto se hace en la ¹2Qiparte. Después de eso, si es igual, empujamos el carácter de espacio 4 veces usando ð4×. Después de eso, empujamos la " U U"cuerda y la almacenamos usando ©(idea descaradamente robada de Jelly: p). Nuevamente nos encontramos en Jla pila e imprimimos esto con una nueva línea. Después de eso, empujamos la "> :"cadena, recuperamos el " U U"uso ®, en Jla pila y Dduplicamos esta cadena e imprimimos ambos en la misma línea.

Breve cuestionario, ¿qué hará esto " > "?®,?

Después de imprimir la cadena anterior, obtenemos el duplicado de la segunda línea de la cara e imprimimos esto (ya que es lo mismo que la segunda línea).

La última parte cubierta por este caso es:

ð6×'U3×J,

ð6×        # Push the space character × 6
   'U3×    # Push the "U" character three times
       J,  # Join and print pop with a newline

N = 1

Este es más fácil de explicar:

¹1QiY

¹1Qi   # Check if the input is equal to 1
    Y  # Push the magpie face
       # This is then implicitly printed

N = 0

¹0Qi"quack

¹0Qi        # Check if the input is equal to 0
    "quack  # Weird sound what magpies make
            # Implicitly printed
Adnan
fuente
Explicación por favor? : P
Addison Crump
@VoteToClose Hecho :)
Adnan
"demasiado tiempo"? Ver mi respuesta :-P
Luis Mendo
2
Hasta que las urracas graznen. Aparentemente.
Alex A.
8

Vitsy , 172 171 159 bytes

Oh cielos. Si quería algo para mostrar el poder de los métodos, lo obtuve.

' 'V1+m
'kcauq'Z
'U:>'Z
58m5m6m'   > 'Z5m6m'UUU'68m
f3+bm9mamcm98m2m6bmcmam9mf6+8m3\[2m]
a'U   U'Z
' :  >'Z5m
Z2m98ma2m
\VZ
2mfbm
VVVZ2m78m2mVV7m
8m7m
68m2m9bm

Pruébalo en línea!

Cómo funciona esto es llamando a varios métodos por sí mismo. La explicación está abajo:

' 'V1+m
' 'V      Save character literal ' ' as a permanent variable.
    1+    Add one to the top item of the stack (input + 1)
      m   Go to that index of code.

'kcauq'Z
'kcauq'   Push 'quack' to the stack.
       Z  Output everything in the stack as a char.

'U:>'Z
'U:>'Z    Ouput ">:U" with the same method as the previous line.

Now on to some more... interesting lines.

58m5m6m'   > 'Z5m6m'UUU'68m
5              Push space, push 4
 8m            Call the 8th line index.
               As we will soon see, the 8th line index duplicates the space
               the number of times specified by the number just before the call 
               (4 in this case)
   5m          Call the 5th line index.
               The 5th line index outputs the 'U   U' and a newline.
     6m        Call the 6th line index.
               The 6th line index outputs '>  : U   U' and a newline.
'   > 'Z       Output ' >   '.
        5m6m   Same method calls as before.
'UUU'          Push 'UUU'.
     68m       Push 6, then call the 8th line index. This gives us the correct padding.

f3+bm9mamcm98m2m6bmcmam9mf6+8m3\[2m]
f3+              Push 18.
   bm            Call the 11th line index.
                 The 11th line index calls the 8th line index (which we've already seen
                 in action) and then the 7th line index, which you can find and explanation
                 for below (it does a lot)
     9m          Call the 9th line index.
                 The 9th line index outputs '>:U               >:U         >:U' (explanation lower)
       am        Call the 10th line index.
                 ...I'm gonna stop explaining these and just tell you to go to the lines now. :P
         cm      Call the 12th line index.
9                Push space, push 9.
 8m              Call the 8th line index (explained below and before).
   2m            Call the 2nd line index.
     6           Push 6.
      bm         Call the 11th line index. We've finished up to '>:U      >:U         >:U' now.
cm               You guessed it! Call the 12th line index. (explanation below)
  am             Call the 10th line index. (explanation below)
    9m           Call the 9th line index. (explanation below)
f6+              Push space, push 19 21.
   8m            Call the 8th line index. (explanation below)
     3\[2m]      Call the 2nd line index thrice.

All of the rest of these methods are supporting methods now.

a'U   U'Z       Output 'U   U' followed by a newline.

' :  >'Z5m      Output '>  : U   U' followed by a newline.

Z2m98ma2m
Z               Output everything currently in the stack.
 2m             Call the 2nd line index.
   9            Push space, push 8.
    8m          Call the 8th line index. (explained below)
      a         Push a newline to the stack.
       2m       Call the 2nd line index.
                This handles the biggest angry duck face's faces showing the eyebrows and eyes.

\VZ
\V    Push space as many times as the top item specifies.
  Z   Output everything in the stack.

2mfbm
2m      Call the 2nd line index.
  f     Push space, push 14.
   bm   Go to the 11th line index.
        This handles the mouth and some parts of the eyebrows of the biggest duck face.

VVVZ2m78m2mVV7m
VVVZ              Output 3 spaces (and whatever was pushed before it)
    2m            Call the 2nd line index.
      7           Push space, push 6.
       8m         Call the 8th line index. (explained... above)
         2m       Call the 2nd line index.
           VV     Push 2 spaces.
             7m   Call the 7th line index.

8m7m     This is pretty damn self-explanatory if you've read this far.

68m2m9bm
6            Push space, push 5.
 8m          Call the 8th line index.
   2m        Call the 2nd line index.
     9       Push space, push 9.
      bm     Call the 11th line index.

Este código es ridículo. Su forma detallada es:

toggle single quote;
 ;
toggle single quote;
save top as permanent variable;
push 1;
add top two;
goto top method;
:toggle single quote;
k;
push 12;
push 10;
flatten top two stacks;
q;
toggle single quote;
output stack as chars;
:toggle single quote;
U;
clone current stack;
go forward;
toggle single quote;
output stack as chars;
:push 5;
push 8;
goto top method;
push 5;
goto top method;
push 6;
goto top method;
toggle single quote;
 ;
 ;
 ;
go forward;
 ;
toggle single quote;
output stack as chars;
push 5;
goto top method;
push 6;
goto top method;
toggle single quote;
U;
U;
U;
toggle single quote;
push 6;
push 8;
goto top method;
:push 15;
push 3;
add top two;
push 11;
goto top method;
push 9;
goto top method;
push 10;
goto top method;
push 12;
goto top method;
push 9;
push 8;
goto top method;
push 2;
goto top method;
push 6;
push 11;
goto top method;
push 12;
goto top method;
push 10;
goto top method;
push 9;
goto top method;
push 15;
push 6;
add top two;
push 8;
goto top method;
push 3;
repeat next instruction set top times;
begin recursive area;
push 2;
goto top method;
end recursive area;
:push 10;
toggle single quote;
U;
 ;
 ;
 ;
U;
toggle single quote;
output stack as chars;
:toggle single quote;
 ;
clone current stack;
 ;
 ;
go forward;
toggle single quote;
output stack as chars;
push 5;
goto top method;
:output stack as chars;
push 2;
goto top method;
push 9;
push 8;
goto top method;
push 10;
push 2;
goto top method;
:repeat next instruction set top times;
save top as permanent variable;
output stack as chars;
:push 2;
goto top method;
push 15;
push 11;
goto top method;
:save top as permanent variable;
save top as permanent variable;
save top as permanent variable;
output stack as chars;
push 2;
goto top method;
push 7;
push 8;
goto top method;
push 2;
goto top method;
save top as permanent variable;
save top as permanent variable;
push 7;
goto top method;
:push 8;
goto top method;
push 7;
goto top method;
:push 6;
push 8;
goto top method;
push 2;
goto top method;
push 9;
push 11;
goto top method;
Addison Crump
fuente
7

JavaScript (ES6), 163 bytes

var solution =

n=>["quack",d=">:U",`5U3U
>2:1U3U
1>3U3U
>2:1U3U
6UUU`,`99090
096090
30702090
609090
906090
609090
30702090
096090
993000`][n].replace(/\d/g,c=>+c?" ".repeat(c):d)
<input type="number" oninput="R.textContent=solution(+this.value)"><pre id="R"></pre>

Explicación

Utiliza mi compresión de inicio con JavaScript: codificación de longitud de ejecución. Los dígitos 1para 9asignar a tantos espacios, los 0mapas para la cara del pato enojado, y cualquier otro personaje permanece igual.

usuario81655
fuente
1
Muy impresionante para un lenguaje que no es de golf, pero las filas justo encima y debajo del centro para n = 3 parecen faltar.
ETHproductions
@ETHproductions Vaya, no estoy seguro de lo que sucedió allí. Corregido ahora.
user81655
7

Japt, 116 105 102 99 96 bytes

["quack""c)`+«öÂ[@=^Gñ`1]o2"mc r'4#¿+R "4z>2:z >2z>2:z6UUU"rz" U3U
" '1]®r'1">:U" r"%d"_SpZ}ÃgU

Contiene un no imprimible. ¡Pruébalo en línea!

Cómo funciona

Las dos primeras cadenas no están comprimidas en absoluto. El tercero se comprime simplemente reemplazando cada serie de espacios con su longitud, luego " U3U"con "z". El último es más complejo:

  1. Reemplace cada corrida de 2-9 espacios con su longitud.
  2. Reemplazar >:Ucon 1.
  3. Reemplazar 191\ncon 4. ( 4no se usa en ningún otro lugar de la cadena).
  4. Asigne cada código de byte válido ( 10- 255o 0A- FF) al carácter con ese código de caracteres.

La cadena resultante tiene solo 21 19 bytes de longitud, pero la descompresión ocupa otros 31 29.

Después de descomprimir las cadenas, simplemente tomamos el elemento en la posición U, la entrada. (La matriz está organizada [0,3,2,1]porque hay un error que hace que cuente desde el final de la matriz en lugar del principio).

[                      // Create an array of the following:
  "quack"              //  "quack".

  "c)`+«öÂ[@=^Gñ`1]o2" //  Take this string (contains an unprintable).
                       //  Map each char to its char code.
                       //  This produces "994196431712461949164619431712419649931112".
  r'4#¿+R              //  Replace each "4" with the char code of "¿" (191) + a newline.

  "4z>2:z >2z>2:z6UUU" //  Take this string.
  rz" U3U\n"           //  Replace each "z" with " U3U\n".

  '1                   //  "1".
]
®              Ã       // Map each item by this function:
r'1">:U"               //  Replace each "1" with ">:U".
r"%d"_SpZ}             //  Replace each remaining digit Z with Z spaces.

gU                     // Get the item at index -U, wrapping. 
                       // (This should just be U, but there's a bug which negates it.)
ETHproducciones
fuente
5

MATL , 283182 bytes

¡101 bytes guardados gracias a @Adnan!

Esto usa números decimales para codificar índices 0... 3a los cuatro caracteres para los casos 2 y 3. Los números decimales tal vez podrían comprimirse usando la codificación de base 64, ¡pero quack!

Para el caso 3 se utiliza un truco muy agradable sugerido por @Adnan: definir secuencias binarias para codificar cada fila, donde 0y 1corresponder al espacio y >:Urespectivamente.

~?'quack'}G1=?'>:U'}G2=?' :>U'12336 8466480h2109488h8466480h4032h4YA47-)}268697600 67174401h16795656h67174464h67174912h67174464h16795656h67174401h14680064h"@BP48+]Xh49'>:U'YX48 32YXc

Pruébalo en línea!

Luis Mendo
fuente
3
¿Qué tal para el último caso, usando esto , reemplazando el 1con espacios y el 0con la >:Ucadena. No sé si eso ayudaría.
Adnan
@Adnan ¡Esa es una buena idea!
Luis Mendo
55
@Adnan 101 bytes guardados: -O
Luis Mendo
¡Esto es increíble! Muy buena respuesta! :)
Adnan
5

Chicle de canela, 76 bytes

0000000: 6c33 502b 2c4d 4cce b636 54b3 b30a b536  l3P+,ML..6T....6
0000010: 5253 0081 5010 e6b2 5350 b082 3215 ecb0  RS..P...SP..2...
0000020: 8a42 1487 865a 1bab 2960 00a0 79c8 6c2e  .B...Z..)`..y.l.
0000030: 2026 a002 4221 0430 55c0 5938 cd40 9720   &..B!.0U.Y8.@. 
0000040: 6c06 6177 90e9 17ac 4102 4100            l.aw....A.A.

No compite desde que se creó Cinnamon Gum después de este desafío.

Pruébalo en línea.

Explicación

El primer byte lespecifica el modo: en este caso, le dice a Cinnamon Gum que ingrese al modo de tabla de búsqueda. Cinnamon Gum luego descomprime el resto de la cadena (que se ha comprimido zopfli --deflate) en esto:

0&quack;1&>:U;2&     U   U
>  : U   U
 >   U   U
>  : U   U
      UUU;3&                  >:U         >:U
>:U               >:U         >:U
   >:U       >:U  >:U         >:U
      >:U         >:U         >:U
         >:U      >:U         >:U
      >:U         >:U         >:U
   >:U       >:U  >:U         >:U
>:U               >:U         >:U
                     >:U>:U>:U

Luego se divide ;, coloca cada par clave-valor (con un &delimitador) en un diccionario y genera salidas dictionary[input].

un espagueti
fuente
5

JavaScript ES6, 232 223 203 188 bytes

Guardado 29 44 bytes gracias a ETHproductions!

n=>[`quack`,r=`>:U`,`     U   U
>  : U   U
 >   U   U
>  : U   U
      UUU`,`00022
10022
0100 1  12
00122
20012
00122
0100 1  12
10022
0000211`.replace(/\d/g,N=>[g=`   `,r,g+g+g+r][N])][n]

¡Pruébalo!

Conor O'Brien
fuente
seguramente se puede atob'd ... si no, podría el 1e 0s puede hacer en un número ternario?
Downgoat
1
@Downgoat btoaing y trinary ambos son más largos.
Conor O'Brien
Vieja respuesta, pero se puede ahorrar como 15 bytes cambiando r+g+g+g+ra g+g+g+ry el ajuste de la cadena en consecuencia.
ETHproductions
0

GML, 265 bytes

Un puerto de la excelente respuesta de @ kittycat3141, con la sugerencia de seguir jugando golf con dos nuevas variables (que denominé G y H) por @VoteToClose. También logré acortarlo aún más con la sintaxis relativamente floja de GML.

d=">:U"A=" "B=A+A;C=B+B;D=C+C;G=D+A;H=C+B;a="U"+B+" U"+"#"c=d+G+d+"#"E=B+A;F=C+E;x[0]="quack"x[1]=d;x[2]=C+A+a+">"+B+": "+a+" >"+E+a+">"+B+": "+a+H+"UUU"x[3]=D+D+B+c+d+D+F+c+B+A+d+F+d+B+c+H+d+G+c+G+d+H+c+H+d+G+c+E+d+F+d+B+c+d+D+F+c+D+D+C+A+d+d+d;return x[argument0]
Timtech
fuente