Votre oiseau a des démangeaisons depuis un peu d'exercice et en a assez d'être coincé dans des positions statiques tout le temps. Écrivez un programme qui montrera un oiseau ascii dansant au hasard, mettant à jour toutes les 100 ms * n ou 200 ms * n selon le mouvement de danse. L'oiseau commence toujours par le mouvement de danse <(")>.

Le programme doit accepter une entrée qui est un nombre pour multiplier l'intervalle de sommeil par ( n >= 0 && n <= 50).

100ms se déplace

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

200 ms se déplace

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

Détails supplémentaires

• L'aléatoire ne doit pas être uniforme, mais chaque mouvement de danse devrait avoir une chance raisonnable de se produire (au moins 1 sur 60 semble juste, c'est OK si le même mouvement se produit deux fois de suite)
• Il ne doit y avoir qu'un seul oiseau à la fois, pas plusieurs oiseaux
• Les espaces de fin sont autorisés (mais les autres caractères de fin ne le sont pas)
• Un oiseau doit être affiché avant le sommeil

Exemple en 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)

Gagnant

• C'est du code-golf donc le moins d'octets gagne!

MATL , 53 octets

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

Les mouvements sont uniformément aléatoires.

Vous trouverez ci-dessous un exemple d'exécution avec n = 2. Ou essayez-le sur MATL Online! (L'interpréteur est expérimental. S'il ne s'exécute pas, essayez à nouveau d'appuyer sur "Exécuter" ou de rafraîchir la page).

Explication

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

Malheureusement, cela ne peut pas être affiché dans TIO car il n'y a pas de "streaming" de la sortie. Voici un gif pour une entrée de à la 1place:

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

Merci @LuisMendo pour -8 octets!

*> <> , 103 101 octets

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

Essayez-le ici! (écrivez nsur la pile initiale ou vous obtiendrez une erreur)

J'ai décidé de tenter mon défi car il n'y avait pas de réponse inférieure à 100 octets. Placer nsur la pile et c'est parti! Cela réutilise les (")caractères pour enregistrer quelques octets.

Explication

Initialisation

<vD[3'(")'

Ici, nous stockons (")pour une utilisation ultérieure.

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

Sélecteur de danse

1x<.5
 \

Ceci est fréquemment exécuté pour sélectionner le type de danse que nous allons générer.

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

Il y a aussi un vau-dessus xet un <à droite. Ceux-ci font que le xget est réexécuté s'il essaie de déplacer l'IP dans la mauvaise direction.

Générez 100ms de danse

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

Ici, nous générons et émettons l'un des mouvements de danse de 100 ms.

 \                         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 - Générez "^" ou "v"

R!"^"x"v">

Il s'agit d'une fonction simple qui génère "^" ou "v" puis retourne. Il fonctionne de manière similaire au sélecteur de danse où il contient des instructions xpour garantir que l'IP ne se déplace que vers la gauche ou la droite.

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

Générez 200ms de danse

C'est un autre qui commence par x. Il sera séparé en deux sections: <(")>et une autre (>")> and <("<), car ce sont deux sections distinctes et xc'est la seule chose qu'elles partagent.

<(")>

>:2* _"><"b2.

Cela fait essentiellement le début de la generate 100ms danceroutine, mais remplit les mains d'oiseaux au ><lieu d'un ^vcombo aléatoire . Il se multiplie également npar deux cette fois. Cela rend tout configuré pour utiliser la generate 100ms danceroutine pour sortir l'oiseau entier et attendre 200 ms à la place.

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

(>")> et <("<)

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

Cette petite explication concerne la génération (>")>et <("<), bien que le xpuisse envoyer l'IP en dehors de celle-ci (expliqué ci-dessous).

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 octets

Javascript: 119 octets

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

J'utilise les millisecondes depuis l'époque pour générer un nombre aléatoire. Théoriquement, cela générerait toujours le même (ensemble de) nombre (s), mais un test sur mon PC m'a donné un résultat assez aléatoire (la plupart des nombres sont apparus plus ou moins également). Il document.getElementById()n'est pas nécessaire non plus d'utiliser le fait que les éléments html avec un identifiant soient ajoutés à l'objet de fenêtre globale en JavaScript .

HTML: 8 octets

<b id=a>

J'omet les guillemets ici et je ne ferme pas la bbalise. Ce n'est pas du HTML valide, mais tous les navigateurs ferment automatiquement la balise quand même. Je l'ai mis en gras parce qu'il bs'agit d'un élément HTML à un caractère et parce que la danse de mon oiseau mérite d'être remarquée.

PowerShell , 124117 octets

(Merci TimmyD )

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

Essayez-le en ligne! (Non pas que cela fonctionnera dans TIO ...)

Noodel , non compétitif 67 octets

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

Ce défi a été très difficile pour Noodel car il ne dispose pas d'opérateurs arithmétiques ou comparatifs intelligents. Mais après avoir relevé ce défi, je pense que Noodel est prêt pour sa première version.

Essayez-le :)

Comment ça marche

                                                                     # 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 octets

Voici une version qui fonctionne comme un extrait de code.

ʠƘṣḳƑðẉḤż’ṀỴ(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 octets

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

J'ai aussi essayé de le faire sans l'art du poulet ascii, mais c'était bien plus long.

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 octets

+1 octet du -ndrapeau.

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

Clojure, 185 178 octets

+18 octets car cela ne commençait pas par <(")>.

-7 octets en insérant birds, et en se débarrassant du 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)))

Il suffit de diviser les oiseaux sur les espaces, de choisir un index aléatoire de 0 à 6, d'afficher l'oiseau choisi, puis si l'index choisi est supérieur à 2, il attend 100 ms, sinon 200 ms.

Clojure a vraiment besoin d'une splitméthode de chaîne dans le noyau.

Non golfé:

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