Niemand ist sich ganz sicher, was das Emoticon darstellen >:Usoll, aber viele Gelehrte glauben, dass es wie eine wütende Ente aussieht . Nehmen wir an, das ist der Fall.

Aufgabe

Geben Sie eine ganze Zahl n zwischen 0 und einschließlich 3 aus oder geben Sie sie zurück

quack

wenn n = 0,

>:U

wenn n = 1,

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

wenn n = 2 oder

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

wenn n = 3.

Sie können davon ausgehen, dass die Eingabe immer gültig ist. Die Ausgabe sollte keinen führenden Speicherplatz enthalten, der nachfolgende Speicherplatz ist jedoch in Ordnung. Enten (mit der möglichen Ausnahme von @cobaltduck) haben keine Toleranz für Schlupflöcher. Kürzester Code in Bytes gewinnt.

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*

Beachten Sie, dass einige Zeichen nicht druckbar sind. Probieren Sie es online!

Hintergrund

Die ersten beiden Ausgänge sind in CJam inkompressibel.

Das Komprimieren der letzten Ausgabe ist unkompliziert. Nachdem alle Zeilenvorschübe entfernt wurden, können wir die resultierende Zeichenfolge bei Auftreten von aufteilen >:Uund die Länge jeder resultierenden Zeichenfolge von Leerzeichen berechnen.

Das ergibt das Array

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

Diese können wir effizient speichern, indem wir sie von der Basis 22 in die Basis 269 umwandeln und die Ziffern erhalten

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

Da jede Ziffer kleiner als 256 ist , können wir sie als einzelnes Byte speichern.

Schließlich wird das Komprimieren der dritten Ausgabe einfacher, wenn wir Zeilen und Spalten transponieren:

 > > 
  >  

 : : 

UUUU 
    U
    U
    U
UUUU

Wenn wir noch einmal die Leerzeichen zwischen Nicht-Leerzeichen zählen, erhalten wir das Array

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

was wird

[115 159 99 84 166 123 36 236 6]

wenn von der Basis 22 zur Basis 269 transkodiert.

Wie es funktioniert

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

17 Bytes gespart dank @VoteToClose!

Eigentlich nicht als die kürzeste gedacht, ich dachte nur, es würde Spaß machen, es in Java zu versuchen.

Erstellt eine Liste von Zeichenfolgenvariablen, die gemeinsame Zeichenfolgen darstellen, erstellt dann ein Array aller Ausgaben und druckt dann die richtige aus.

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

Dies ist meine erste Antwort auf dieser Seite. Bitte teilen Sie mir mit, wenn ich etwas falsch gemacht habe.

05AB1E , 162 159 157 Bytes

Code

Verdammt, viel zu lang, aber es ist wenigstens etwas:

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

Probieren Sie es online!

Erläuterung

Der erste Teil des Codes besteht aus ">:U"V, der Yauf diesen String gesetzt wird. Danach prüfen wir nur, ob die Eingabe gleich 3 ist. Das wird am I3QiTeil gemacht. Wenn gleich, drucken wir die Riesenelster:

N = 3

Es beginnt damit, ð16×dass nur 16 Leerzeichen gedrückt werden. Danach gibt es eine Nummer 7166b. Dies deckt den ">:U "Teil mit ein wenig Hilfe von Retina ab :). Ich habe dieses Skript verwendet , um den String in eine Binärzahl umzuwandeln. Danach kommen wir zu dem 1ð:0Y:Teil, der jedes 1durch ein Leerzeichen und jedes 0durch das Y, was gesetzt wurde, ersetzt >:U. Danach Dduplizieren wir diesen String, speichern ihn in Xusing Uund Jfügen ihn in den Stack ein. Wir setzen dies mit ein ,, wodurch die gesamte Zeichenkette mit einem Zeilenumbruch gedruckt wird. Alle anderen danach basieren alle auf demselben Prinzip. Die if-Anweisung endet mit der Sekunde }.

Die vollständige Konvertierung finden Sie hier .

N = 2

Wir prüfen nun, ob die Eingabe gleich 2 ist. Dies erfolgt am ¹2QiTeil. Danach drücken wir, falls gleich, das Leerzeichen viermal mit ð4×. Danach schieben wir die " U U"Schnur und speichern sie mit ©(Idee, die Jelly offensichtlich gestohlen hat: p). Wir Jsetzen uns wieder in den Stapel und drucken dies mit einer neuen Zeile. Danach schieben wir den "> :"String, holen den " U U"using- Befehl ®, Jfügen ihn in den Stack ein, Dduplizieren diesen String und drucken beide in dieselbe Zeile.

Kurzes Quiz, was bringt das " > "?®,?

Nach dem Drucken der obigen Zeichenfolge erhalten wir das Duplikat der zweiten Zeile des Gesichts und drucken dieses aus (da es dasselbe wie die zweite Zeile ist).

Der letzte Teil, der in diesem Fall behandelt wird, ist:

ð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

Dieser ist einfacher zu erklären:

¹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 Bytes

Oh mein Gott. Wenn ich etwas wollte, um die Kraft der Methoden zu demonstrieren, dann habe ich es verstanden.

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

Probieren Sie es online!

Wie dies funktioniert, ist durch Aufrufen verschiedener Methoden in sich. Die Erklärung ist unten:

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

Dieser Code ist lächerlich. Die ausführliche Form lautet:

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 Byte

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>

Erläuterung

Verwendet meine automatische Komprimierung mit JavaScript: Lauflängencodierung. Die Ziffern 1, die 9auf so viele Felder abgebildet werden sollen, die 0Abbildungen auf das Gesicht der wütenden Ente und alle anderen Zeichen bleiben gleich.

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

Enthält eine nicht druckbare. Online testen!

Wie es funktioniert

Die ersten beiden Zeichenfolgen werden überhaupt nicht komprimiert. Die dritte wird einfach komprimiert, indem die einzelnen Leerzeichenfolgen durch ihre Länge und dann " U3U"durch ersetzt werden "z". Der letzte ist komplexer:

1. Ersetzen Sie jeden Lauf von 2-9 Stellen durch seine Länge.
2. Ersetzen >:Udurch 1.
3. Ersetzen 191\ndurch 4. ( 4Wird nirgendwo anders in der Zeichenfolge verwendet.)
4. Ordnen Sie jedem gültigen Bytecode ( 10- 255oder 0A- FF) das Zeichen mit diesem Zeichencode zu.

Die resultierende Zeichenfolge ist nur 21 bis 19 Byte lang, die Dekomprimierung nimmt jedoch weitere 31 bis 29 Byte in Anspruch .

Nachdem wir die Strings dekomprimiert haben, nehmen wir einfach das Item an der Position U, die Eingabe. (Das Array ist angeordnet, [0,3,2,1]weil es einen Fehler gibt, der es vom Ende des Arrays anstelle des Anfangs zählen lässt.)

[                      // 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 Bytes

101 Bytes gespart dank @Adnan!

Dies verwendet Dezimalzahlen, um Indizes 0... 3zu den vier Zeichen für die Fälle 2 und 3 zu codieren . Die Dezimalzahlen könnten möglicherweise unter Verwendung der Base-64-Codierung komprimiert werden, aber quaken Sie!

Für den Fall 3 wird ein von @Adnan vorgeschlagener sehr netter Trick verwendet: Definieren Sie Binärsequenzen, um jede Zeile zu codieren, wobei 0und 1entsprechend Leerzeichen und >:U.

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

Probieren Sie es online!

Zimtgummi, 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.

Nicht konkurrierend, da Zimtgummi nach dieser Herausforderung hergestellt wurde.

Probieren Sie es online aus.

Erläuterung

Das erste Byte lgibt den Modus an: In diesem Fall weist es Cinnamon Gum an, in den Nachschlagetabellenmodus zu wechseln. Cinnamon Gum dekomprimiert dann den Rest der Saite (mit der komprimiert wurde zopfli --deflate) in diese:

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

Anschließend wird durch geteilt ;, jedes Schlüssel-Wert-Paar (mit &Trennzeichen) in ein Wörterbuch eingefügt und ausgegeben dictionary[input].

JavaScript ES6, 232 223 203 188 Bytes

Gespeichert 29 44 Byte dank 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]

Probieren Sie es aus!

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 Bytes

Ein Port von @ kittycat3141s hervorragender Antwort, mit dem Vorschlag, ihn mit zwei neuen Variablen (die ich G und H nannte) von @VoteToClose weiter zu verbessern. Ich habe es auch geschafft, es mit der relativ losen GML-Syntax weiter zu verkürzen.

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]