Tu pájaro ha estado picando por algo de ejercicio y está harto de estar atrapado en posiciones estáticas todo el tiempo. Escriba un programa que muestre un pájaro ascii bailando al azar, actualizándose cada 100 ms * no 200 ms * n según el movimiento de baile. El pájaro siempre comienza con el movimiento de baile <(")>.

El programa debe aceptar una entrada que es un número para multiplicar el intervalo de suspensión por ( n >= 0 && n <= 50).

Movimientos de 100 ms

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

200 ms movimientos

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

Detalles extra

• La aleatoriedad no tiene que ser uniforme, pero cada movimiento de baile debe tener una probabilidad razonable de ocurrir (al menos 1 de cada 60 parece justo, está bien si el mismo movimiento ocurre dos veces seguidas)
• Solo debe mostrarse un pájaro a la vez, no múltiples pájaros
• El espacio en blanco al final está permitido (pero otros caracteres finales no están permitidos)
• Se debe mostrar un pájaro antes de dormir

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

Victorioso

• Este es el código de golf, ¡ por lo que gana menos bytes!

MATL , 53 bytes

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

Los movimientos son uniformemente aleatorios.

A continuación se muestra una muestra con n = 2. ¡O pruébalo en MATL Online! (El intérprete es experimental. Si no se ejecuta inicialmente, intente presionar "Ejecutar" nuevamente o actualizar la página).

Explicación

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

Desafortunadamente, esto no se puede mostrar en TIO ya que no hay "transmisión" de la salida. Aquí hay un gif para una entrada de en su 1lugar:

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

¡Gracias @LuisMendo por -8 bytes!

*> <> , 103101 bytes

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

Pruébalo aquí! (escriba en nla pila inicial o obtendrá un error)

Decidí probar mi desafío ya que no había respuestas de menos de 100 bytes. Coloca nen la pila y ¡listo! Esto reutiliza los (")caracteres para guardar algunos bytes.

Explicación

Inicialización

<vD[3'(")'

Aquí almacenamos (")para su uso posterior.

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

Selector de baile

1x<.5
 \

Esto se ejecuta con frecuencia para seleccionar qué tipo de baile vamos a generar.

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

Hay una v arriba xy un <a la derecha. Esto hace que xse vuelva a ejecutar si intenta mover la IP en la dirección incorrecta.

Genera 100 ms de baile

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

Aquí generamos y sacamos uno de los movimientos de baile 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 - Genera "^" o "v"

R!"^"x"v">

Esta es una función simple que genera "^" o "v" y luego regresa. Funciona de manera similar al selector de baile donde tiene instrucciones sobrex para garantizar que la IP solo se mueva hacia la izquierda o hacia la derecha.

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

Genera 200 ms de baile

Este es otro que comienza con x. Se separará en dos secciones: <(")>y otra (>")> and <("<), porque son dos secciones distintas y xes lo único que comparten.

<(")>

>:2* _"><"b2.

Básicamente, esto hace el comienzo de la generate 100ms dancerutina, pero llena las manos del pájaro como ><un ^vcombo aleatorio . Se multiplica npor dos esta vez también. Esto hace que todo esté configurado para utilizar la generate 100ms dancerutina para generar el pájaro completo y esperar 200 ms en su lugar.

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

(>")> y <("<)

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

Esta pequeña explicación es sobre la generación (>")>y <("<), aunque xpuede enviar la IP fuera de ella (se explica a continuación).

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: 118116 + 8 = 124 bytes

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

Estoy usando los milisegundos desde la época para generar un número aleatorio. Teóricamente, esto siempre generaría el mismo (conjunto de) número (s), pero una prueba en mi PC me dio un resultado bastante aleatorio (la mayoría de los números aparecieron más o menos por igual). También usando el hecho de que los elementos html con una identificación se agregan al objeto de ventana global en JavaScript, por lo quedocument.getElementById() lo que no es necesario.

HTML: 8 bytes

<b id=a>

Estoy omitiendo las citas aquí y no estoy cerrando la betiqueta. No es html válido, pero todos los navegadores cierran automáticamente la etiqueta de todos modos. Lo puse en negrita porque bes un elemento HTML de un carácter y porque el baile de mi pájaro merece ser notado.

PowerShell , 124117 bytes

(Gracias TimmyD )

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

Pruébalo en línea! (No es que funcione en TIO ...)

Noodel , 67 bytes no competitivos

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

Este desafío fue muy difícil para Noodel porque no tiene operadores aritméticos inteligentes o comparativos. Pero después de hacer este desafío, creo que Noodel está listo para su primer lanzamiento.

Intentalo:)

Cómo funciona

                                                                     # 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

Aquí hay una versión que funciona como un fragmento de código.

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

También intenté hacerlo sin el pollo ascii art, pero eso fue mucho más tiempo.

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 de la -nbandera.

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 porque no comenzaba con <(")> .

-7 bytes en línea birds y deshaciéndose de 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)))

Simplemente divide las aves en los espacios, elige un índice aleatorio de 0-6, muestra el ave elegida, luego, si el índice elegido es mayor que 2, espera 100 ms, de lo contrario 200 ms.

Clojure realmente necesita una cuerda split método de en el núcleo.

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