Personne ne sait vraiment ce que l’émoticône >:Uest destiné à représenter, mais de nombreux spécialistes pensent que cela ressemble à un canard en colère . Supposons que c'est le cas.

Tâche

Soit un entier n compris entre 0 et 3 inclus, à imprimer ou à retourner

quack

si n = 0,

>:U

si n = 1,

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

si n = 2, ou

                  >: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.

Vous pouvez supposer que la saisie sera toujours valide. Il ne doit y avoir aucun espace de début dans la sortie, mais toute quantité d’espace de fuite est acceptable. Les canards (à l'exception possible de @cobaltduck) n'ont aucune tolérance pour les échappatoires. Le code le plus court en octets gagne.

CJam, 108 90 85 octets

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

Notez que certains caractères ne sont pas imprimables. Essayez-le en ligne!

Contexte

Les deux premières sorties sont incompressibles dans CJam.

La compression de la dernière sortie est simple. Une fois tous les sauts de ligne supprimés, nous pouvons fractionner la chaîne résultante en occurrences de >:Uet calculer la longueur de chaque chaîne d'espaces résultante.

Cela se traduit par le tableau

[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 nous pouvons stocker efficacement en le convertissant de la base 22 à la base 269, donnant les chiffres

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

Comme chaque chiffre est inférieur à 256 , nous pouvons le stocker sous la forme d'un seul octet.

Enfin, la compression de la troisième sortie devient plus facile si nous transposons des lignes et des colonnes:

 > > 
  >  

 : : 

UUUU 
    U
    U
    U
UUUU

En comptant une fois de plus les espaces entre les caractères non-blancs, nous obtenons le tableau

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

qui devient

[115 159 99 84 166 123 36 236 6]

transcodé de la base 22 à la base 269.

Comment ça fonctionne

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

Java, 303 286 octets

Sauvegardé 17 octets grâce à @VoteToClose!

En réalité, je pensais que ce serait amusant d'essayer en Java.

Crée une liste de variables de chaîne représentant des chaînes communes, puis crée un tableau de toutes les sorties, puis affiche la bonne.

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

Ungolfed:

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

Ceci est ma première réponse sur ce site, alors s'il vous plaît dites-moi si j'ai fait quelque chose de mal.

05AB1E , 162 159 157 octets

Code

Bon sang, bien trop long, mais c'est au moins quelque chose:

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

Essayez-le en ligne!

Explication

La première partie du code existe ">:U"V, qui définit Ycette chaîne. Après cela, nous vérifions simplement si l'entrée est égale à 3. Cela se fait à la I3Qipièce. Si égal, nous imprimons la pie géante:

N = 3

Cela commence par ð16×quoi il suffit de pousser 16 caractères d'espace. Après cela, il y a un numéro 7166b. Cela couvre la ">:U "partie, avec un peu d'aide de Retina :). J'ai utilisé ce script pour convertir la chaîne en un nombre binaire. Après cela, nous arrivons à la 1ð:0Y:partie, qui remplace chaque 1avec un caractère d'espacement et chaque 0avec Y, qui a été défini sur >:U. Après cela, nous Duplicate cette chaîne, le stocker dans l' Xutilisation Uet JOIN la pile. Nous sautons ceci en utilisant ,, qui imprime la chaîne complète avec une nouvelle ligne. Tous les autres suivants sont tous basés sur le même principe. La déclaration if se termine à la seconde }.

La conversion complète peut être trouvée ici .

N = 2

Nous vérifions maintenant si l'entrée est égale à 2. Ceci est fait à la ¹2Qipièce. Après cela, si égal, nous poussons le caractère espace 4 fois en utilisant ð4×. Après cela, nous poussons la " U U"corde et la stockons avec ©(idée volée de manière flagrante à Jelly: p). Nous Jretrouvons la pile et l’imprimons avec une nouvelle ligne. Après cela, nous poussons la "> :"chaîne, récupérons l’ " U U"utilisation ®, Jla pile, puis Dmettons cette chaîne en place et les imprimons tous les deux sur la même ligne.

Petit quiz, qu'est-ce que ça va faire " > "?®,?

Après avoir imprimé la chaîne ci-dessus, nous obtenons le duplicata de la deuxième ligne du visage et l’imprimons (puisque c’est la même chose que la deuxième ligne).

La dernière partie couverte par cette affaire est:

ð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

Celui-ci est plus facile à expliquer:

¹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

Vitsy , 172 171 159 octets

Oh bon sang. Si je voulais quelque chose pour montrer le pouvoir des méthodes, je l'ai.

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

Essayez-le en ligne!

Comment cela fonctionne est en appelant diverses méthodes tout au long de lui-même. L'explication est ci-dessous:

' '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.

Ce code est ridicule. Sa forme verbeuse est:

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;

JavaScript (ES6), 163 octets

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>

Explication

Utilise ma compression go-to avec JavaScript: le codage de durée d'exécution. Les chiffres 1à 9mapper sur autant d'espaces, ceux 0sur le visage de canard en colère et tous les autres personnages restent les mêmes.

Japt, 116 105 102 99 96 octets

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

Contient un non imprimable. Testez-le en ligne!

Comment ça fonctionne

Les deux premières chaînes ne sont pas compressées du tout. Le troisième est compressé simplement en remplaçant chaque série d'espaces par sa longueur, puis " U3U"par "z". Le dernier est plus complexe:

1. Remplacez chaque série de 2 à 9 espaces par sa longueur.
2. Remplacer >:Upar 1.
3. Remplacer 191\npar 4. ( 4n'est utilisé nulle part ailleurs dans la chaîne.)
4. Mappez chaque code d'octet valide ( 10- 255, ou 0A- FF) au caractère portant ce code de caractère.

La chaîne résultante ne fait que 21 19 octets de long, mais la décompression en prend encore 31 29.

Après avoir décompressé les chaînes, nous prenons simplement l'élément à la position U, l'entrée. (Le tableau est arrangé [0,3,2,1]car il y a un bogue qui le rend compte à partir de la fin du tableau au lieu du début.)

[                      // 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.)

MATL , 283 182 octets

101 octets sauvés grâce à @Adnan!

Ceci utilise des nombres décimaux pour coder des index 0... 3sur les quatre caractères des cas 2 et 3. Les nombres décimaux pourraient peut-être être compressés à l'aide d'un codage en base 64, mais c'est un charlatan!

Dans le cas 3, un très beau tour suggéré par @Adnan est utilisé: définissez des séquences binaires pour coder chaque ligne, où 0et 1correspondent à l'espace et >:Urespectivement.

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

Essayez-le en ligne!

Gomme à la cannelle, 76 octets

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.

Non compétitif depuis que Cinnamon Gum a été créé après ce défi.

Essayez-le en ligne.

Explication

Le premier octet lspécifie le mode: dans ce cas, il indique à Cinnamon Gum d'entrer en mode table de consultation. Cinnamon Gum décompresse ensuite le reste de la chaîne (qui a été compressée avec zopfli --deflate) dans ceci:

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

Il se divise ensuite en ;, met chaque paire clé-valeur (avec &comme délimiteur) dans un dictionnaire, et génère des sorties dictionary[input].

JavaScript ES6, 232 223 203 188 octets

Sauvegardé 29 44 octets grâce à 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]

Testez-le!

A=n=>[`quack`,r=`>:U`,`     U   U
>  : U   U
 >   U   U
>  : U   U
      UUU`,`0000002
1000002
0100 1  2
0010002
0001002
0010002
0100 1  2
1000002
0000000111`.replace(/\d/g,N=>[g=`   `,r,r+g+g+g+r][N])][n]

(a.onchange=a.onkeydown=a.onkeyup=function(){
 o.innerHTML = A(+a.value);
})();

*{font-family:"Consolas",monospace;font-size:20px;white-space:pre-wrap}input{left:50%;width:150px;position:absolute;text-align:center;margin-left:-75px;}#o{margin:15px;border:1px solid #00ACDC;padding:15px;}

<input id=a type=number value=0 min=0 max=3><br><div id=o></div>

GML, 265 octets

La réponse excellente de @ kittycat3141 du port, avec la suggestion de jouer plus loin avec deux nouvelles variables (que j'ai nommées G et H) de @VoteToClose. J'ai également réussi à le raccourcir davantage avec la syntaxe relativement souple 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]