Ihr Vogel juckt seit einiger Zeit und hat es satt, ständig in statischen Positionen zu stecken. Schreiben Sie ein Programm, das einen zufällig tanzenden Ascii-Vogel zeigt und je nach Tanzbewegung alle 100ms * n oder 200ms * n aktualisiert. Der Vogel beginnt immer mit der Tanzbewegung <(")>.

Das Programm sollte eine Eingabe akzeptieren, die eine Zahl ist, um das Ruheintervall mit ( n >= 0 && n <= 50) zu multiplizieren .

100ms bewegt

^(")v
v(")^
^(")^
v(")v

200ms bewegt

(>")>
<(")>
<("<)

Zusätzliche Details

• Zufälligkeit muss nicht einheitlich sein, aber jede Tanzbewegung sollte eine vernünftige Chance haben (mindestens 1 von 60 scheint fair zu sein, es ist in Ordnung, wenn dieselbe Bewegung zweimal hintereinander ausgeführt wird).
• Es sollte immer nur ein Vogel angezeigt werden, nicht mehrere
• Leerzeichen dürfen nachgestellt werden (andere nachgestellte Zeichen jedoch nicht)
• Ein Vogel sollte vor dem Schlaf angezeigt werden

Beispiel in Python 3

import random, time, sys

birds = """(>")>
<(")>
<("<)
^(")v
v(")^
^(")^
v(")v"""
birds = birds.split()

interval = int(input("Sleep for 100ms*"))
selection = -1

while True:
    if selection == -1:
        selection = 1
    else:
        selection = random.randint(0, len(birds)-1)
    sys.stdout.write('\r'+birds[selection])
    if selection > 2:
        time.sleep(0.1*interval)
    else:
        time.sleep(0.2*interval)

Gewinnen

• Das ist Code-Golf, also gewinnt mindestens Byte!

MATL , 53 Bytes

xXx`'./U;HbG#3@@!{uu'F'v^<>(")'Za7e 7YrY)D5M3>QG*&XxT

Bewegungen sind gleichmäßig zufällig.

Unten ist ein Probelauf mit n = 2. Oder probieren Sie es bei MATL Online! (Der Interpreter ist experimentell. Wenn er anfänglich nicht ausgeführt wird, drücken Sie erneut auf "Ausführen" oder aktualisieren Sie die Seite.)

Erläuterung

x                   % Take input n and delete it
Xx                  % Clear screen
`                   % Do...while
  './U;HbG#3@@!{uu' %   Push this (compressed) string
  F                 %   Specify source alphabet for decompression
  'v^<>(")'         %   Push target alphabet
  Za                %   Base conversion (decompress)
  7e                %   Reshape as a 7-row char matrix. Each row is a move
  7Yr               %   Push random integer from 1 to 7
  Y)                %   Select that row from the char matrix
  D                 %   Display it
  5M                %   Push the integer again
  3>                %   Does it exceed 3? Gives false (0) or true (1)
  Q                 %   Add 1
  G*                %   Multiply by n
  &Xx               %   Pause that many tenths of a second and clear screen
  T                 %   Push true
                    % End (implicit). Since top of the stack is true, this causes
                    % and infinite loop

Matlab, 125 117 Bytes

Leider kann dies nicht in TIO angezeigt werden, da der Ausgang nicht "gestreamt" wird. Hier ist ein GIF für eine Eingabe von 1:

t=input('')*.1;a='^(")vv(")^^(")^v(")v(>")><(")><("<)';while 1;n=randi(7);clc;disp(a(n*5-4:n*5));pause(t+t*(n>4));end

Danke @LuisMendo für -8 Bytes!

*> <> , 103 101 Bytes

<vD[3'(")'
1x<.5
S\:43_C43CdooI:o@:o@:o@Do
R!"^"x"v">
>:2* _"><"92.
x '>)">('u.02S*2:oooooodO<'<("<)'

Probieren Sie es hier aus! (Schreiben Sie in nden Anfangsstapel, sonst wird eine Fehlermeldung angezeigt.)

Ich beschloss, meine Herausforderung anzupacken, da es keine Antworten unter 100 Byte gab. Platz nauf dem Stack und gehen Sie weg! Dadurch werden die (")Zeichen wiederverwendet , um einige Bytes zu speichern.

Erläuterung

Initialisierung

<vD[3'(")'

Hier speichern wir (")zur späteren Verwendung.

<           move the IP left
   [3'(")'  push '(")' to a new stack
  D         move back down to a clean stack
 v          move the IP down into "dance chooser"

Tanzwähler

1x<.5
 \

Dies wird häufig ausgeführt, um auszuwählen, welche Art von Tanz erzeugt werden soll.

 x         generate a 100ms dance or a 200ms dance
1  .5      jump to "200ms dance"
 \         mirror IP into "100ms dance"

Es gibt auch ein vdarüber xund ein <rechts davon. Diese veranlassen die xerneute Ausführung, wenn versucht wird, die IP in die falsche Richtung zu verschieben.

Generiere 100ms Tanz

S\:1*43_C43CdooI:o@:o@:o@Do

Hier erzeugen wir eine der 100ms Tanzbewegungen und geben sie aus.

 \                         mirror the IP right
  :                        copy n
   43 C43C                 call "generate '^' or 'v'" twice
     _                     ignored mirror
          do               output a carriage return
            o              output the first hand of the bird
             I:o@:o@:o@D   select, copy, and output '(")'
                        o  output the second hand of the bird
S                          sleep for previous n*100ms
 \                         mirror IP back to "dance chooser"

43C - "^" oder "v" erzeugen

R!"^"x"v">

Dies ist eine einfache Funktion, die "^" oder "v" generiert und dann zurückgibt. Es funktioniert ähnlich wie der Tanzwähler, in dem Anweisungen vorhanden sind, um xsicherzustellen, dass sich die IP nur nach links oder rechts bewegt.

     x      generate "^" or "v"
R!"^"    >  push "^" to stack and return
R     "v"   push "v" to stack and return

200ms Tanz erzeugen

Dies ist eine andere, die mit beginnt x. Es wird in zwei Abschnitte unterteilt: <(")>und einen weiteren (>")> and <("<), da es sich um zwei unterschiedliche Abschnitte handelt und xder einzige ist, den sie teilen.

<(")>

>:2* _"><"b2.

Dies ist im Grunde genommen der Anfang der generate 100ms danceRoutine, füllt aber die Vogelhände wie ><bei einer zufälligen ^vKombination. Auch ndiesmal multipliziert es sich mit zwei. Dies macht es zum Setup, die generate 100ms danceRoutine zu verwenden, um den gesamten Vogel auszugeben und stattdessen 200 ms zu warten.

>              move IP right
 :2*           copy n and do n*2
     _         ignored mirror
      "><"     push "><" to stack
          b2.  jump to "output carriage return" in "generate 100ms dance"

(>")> und <("<)

x '>)">('u.02S*2:oooooodO<'<("<)'

Diese kleine Erklärung bezieht sich auf die (>")>und <("<)-Erzeugung, obwohl xdie IP außerhalb davon gesendet werden kann (unten erklärt).

x                                  move to "choose dance", generate (>")>, <("<), or <(")> (previous routine)  
  '>)">('                          push '(>")>' to the stack
                          '<("<)'  push '<("<)' to the stack
         u              O<         ensure inner code block is always executed with IP moving left
                      od           output carriage return
                 ooooo             output bird
             S*2:                  sleep for n*200ms
          .02                      jump to "dance chooser"

JavaScript (ES6) + HTML5: 118 116 + 8 = 124 Byte

Javascript: 119 Bytes

f=n=>{a.innerHTML='(>")>0<(")>0<("<)0^(")v0v(")^0^(")^0v(")v'.split(0)[r=+new Date%7],setTimeout(f,(1+(r<3))*100*n,n)}

Ich benutze die Millisekunden seit der Epoche, um eine zufällige Zahl zu generieren. Theoretisch würde dies immer die gleichen Zahlen erzeugen, aber ein Test auf meinem PC ergab ein ziemlich zufälliges Ergebnis (die meisten Zahlen erschienen mehr oder weniger gleich). Außerdem wird die Tatsache, dass HTML-Elemente mit einer ID zum globalen Fensterobjekt in JavaScript hinzugefügt werden, document.getElementById()nicht benötigt.

HTML: 8 Bytes

<b id=a>

Ich lasse die Anführungszeichen hier weg und schließe das bTag nicht. Es ist kein gültiges HTML, aber alle Browser schließen das Tag trotzdem automatisch. Ich habe es mutig gemacht, weil bes sich um ein Ein-Zeichen-HTML-Element handelt und weil der Tanz meines Vogels es verdient, bemerkt zu werden.

PowerShell , 124 - 117 Byte

(Danke TimmyD )

for(){(-split'^(")v v(")^ ^(")^ v(")v (>")> <(")> <("<)')[($i=0..6|random)];sleep -m((100,200)[$i-gt3]*$args[0]);cls}

Probieren Sie es online! (Nicht, dass es in TIO funktionieren wird ...)

Noodel , nicht konkurrierende 67 Bytes

ʠƘṣḳƑðẉḤż’ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð
ḊḢðḞ’ṀḌcṀḌcİ8c¬ððɲḷṛḋʠṡʠạÇƥƥạƥḋʠ⁺µḍ

Diese Herausforderung war für Noodel sehr schwierig, da es keine intelligenten arithmetischen oder vergleichenden Operatoren gibt. Aber nach dieser Herausforderung denke ich, dass Noodel für die erste Veröffentlichung bereit ist.

Versuch es:)

Wie es funktioniert

                                                                     # Note: The input is immediately pushed onto the stack.
ʠ                                                                    # Moves the pointer for the top of the stack down one.
 ƘṣḳƑðẉḤż’ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð                                      # Creates a string based off of the key "ƘṣḳƑðẉḤż" and the compressed text "ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð" to create "^(")vðv(")^ð^(")^ðv(")vð(>")>ð<(")>ð<("<)" which then gets split by the null character "ð" to create an array of strings which gets pushed to the stack.
                               \n                                    # A new line to separate the literals.
                                 ḊḢðḞ’ṀḌcṀḌcİ8c¬ðð                   # Creates a string based off of the key "ḊḢðḞ" and the compressed text "ṀḌcṀḌcİ8c¬ðð" to create "100ð100ð100ð100ð200ð200ð200" which then gets split the same way as before.
                                                  ɲ                  # Turns each element in the array into a number creating the array of delays.
                                                   ḷ                 # Loops the rest of the code unconditionally.
                                                    ṛ                # Generates a random number from 0 to the length-1 of the array on top of the stack.
                                                     ḋ               # Duplicates the random number.
                                                      ʠ              # Moves the stack pointer down to save one of the random numbers for later.
                                                       ṡ             # Swap the array with the random number such that the array is on top again.
                                                        ʠ            # Moves the stack pointer down such that the random number is on top.
                                                         ạ           # Uses the random number to access the bird array which is now after the random number and pushes the element onto the stack.
                                                          Ç          # Clears the screen and pops the bird and pushes it to the screen.
                                                           ƥƥ        # Moves the stack pointer up two times such that the random number is the top.
                                                             ạ       # Use the random number to access the array with delays and pushes that item onto the stack.
                                                              ƥ      # Moves the stack pointer up in order to have the input on top.
                                                               ḋ     # Duplicates the users input.
                                                                ʠ    # Moves the stack pointer back down in order to have the user input on top followed by the random item from the delay array.
                                                                 ⁺µ  # This command pops two numbers off and multiplies them and pushes the result back on.
                                                                   ḍ # Pops off of the stack and uses that as a delay in milliseconds.

64 Bytes

Hier ist eine Version, die als Code-Snippet funktioniert.

ʠƘṣḳƑðẉḤż’ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð EAð¶’Ṁ|ṢĿ<h4¶¬ȥḷṛḋʠṡʠạÇƥƥạƥḋʠ⁺µḍ

<div id="noodel" code="ʠƘṣḳƑðẉḤż’ṀỴ(EḞ4ĊḌṀY%¤ĠẸG^ḞðxỌð EAð¶’Ṁ|ṢĿ<h4¶¬ȥḷṛḋʠṡʠạÇƥƥạƥḋʠ⁺µḍ" input="2" cols="5" rows="3"></div>

<script src="https://tkellehe.github.io/noodel/release/noodel-1.1.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>

Python, 157 Bytes

import time,random;n,m=5,int(input())
while 1:print('(>")><(")><("<)^(")vv(")^^(")^v(")v'[n:n+5]);time.sleep((.1+(n<15)/10)*m);n=(n+random.randint(1,6)*5)%35

Ich habe auch versucht, es ohne die Hühnchen-Ascii-Kunst zu machen, aber das war viel länger.

import time,random;n,m=5,int(input())
while 1:
  print(['^v'[n%2]+'(")'+'v^'[0<n<3],''.join(map(chr,[40+20*(n>4),62-22*(n>4),34,41+19*(n>5),62-21*(n>5)]))][n>3])
  time.sleep((.1+(n>3)/10)*m);n=(n+random.randint(1,6))%7

Ruby, 97 + 1 = 98 Bytes

+1 Byte von der -nFlagge.

a=1;loop{puts %w{^(")v <(")> v(")^ (>")> ^(")^ <("<) v(")v}[a];sleep$_.to_i*0.1*(1+a%2);a=rand 7}

Clojure, 185 178 Bytes

+18 Bytes, weil es nicht mit anfing <(")>.

-7 Bytes durch Inlinen birdsund Entfernen des let.

#(loop[m nil r(or m 1)](print"\r"((clojure.string/split"(>\")> <(\")> <(\"<) ^(\")v v(\")^ ^(\")^ v(\")v"#" ")r))(flush)(Thread/sleep(*(if(> r 2)100 200)%))(recur 1(rand-int 7)))

Teilen Sie die Vögel einfach auf Leerzeichen auf, wählen Sie einen zufälligen Index von 0-6 aus, und zeigen Sie den ausgewählten Vogel an. Wenn der ausgewählte Index größer als 2 ist, wartet er 100 ms, ansonsten 200 ms.

Clojure braucht wirklich eine String- splitMethode im Kern.

Ungolfed:

(defn dancing-bird [n]
  (loop [m nil]
    (let [birds (clojure.string/split "(>\")> <(\")> <(\"<) ^(\")v v(\")^ ^(\")^ v(\")v" #" ")
          rand-i (or m 1)]
      (print "\r" (birds rand-i))
      (flush)
      (Thread/sleep (* (if (> r 2) 100 200) n))
      (recur (rand-int 7)))))