Il tuo uccello ha prurito per un po 'di esercizio ed è stanco di rimanere bloccato in posizioni statiche tutto il tempo. Scrivi un programma che mostrerà un uccello ascii che balla in modo casuale, aggiornando ogni 100ms * n o 200ms * n a seconda della mossa della danza. L'uccello inizia sempre con la mossa della danza <(")>.

Il programma dovrebbe accettare un input che è un numero per moltiplicare l'intervallo di sospensione per ( n >= 0 && n <= 50).

Mosse di 100ms

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

200 mosse

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

Dettagli extra

• La casualità non deve essere uniforme ma ogni mossa di danza dovrebbe avere ragionevoli probabilità di verificarsi (almeno 1 su 60 sembra giusto, va bene se la stessa mossa si verifica due volte di seguito)
• Dovrebbe essere visualizzato solo un uccello alla volta, non più uccelli
• Spazio bianco finale consentito (ma altri caratteri finali non lo sono)
• Un uccello dovrebbe essere visualizzato prima del sonno

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

vincente

• Questo è il golf del codice quindi vince meno byte!

MATL , 53 byte

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

Le mosse sono uniformemente casuali.

Di seguito è riportato un esempio di esecuzione con n = 2. Oppure provalo su MATL Online! (L'interprete è sperimentale. Se inizialmente non viene eseguito, prova a premere nuovamente "Esegui" o ad aggiornare la pagina).

Spiegazione

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 byte

Sfortunatamente questo non può essere visualizzato in TIO in quanto non c'è "streaming" dell'output. Ecco una gif per un input di 1invece:

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

Grazie @LuisMendo per -8 byte!

*> <> , 103 101 byte

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

Provalo qui! (scrivi nello nstack iniziale o otterrai un errore)

Ho deciso di dare un colpo alla mia sfida poiché non c'erano risposte inferiori a 100 byte. Metti nin pila e via! Questo riutilizza i (")caratteri per salvare alcuni byte.

Spiegazione

Inizializzazione

<vD[3'(")'

Qui memorizziamo (")per un uso successivo.

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

Selettore di danza

1x<.5
 \

Questo viene spesso eseguito per selezionare il tipo di danza che genereremo.

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

C'è anche un vsopra xe un <a destra. Questi rendono ilx nuovamente l'esecuzione se tenta di spostare l'IP nella direzione sbagliata.

Genera 100ms di danza

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

Qui generiamo e produciamo una delle mosse di ballo da 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">

Questa è una semplice funzione che genera "^" o "v", quindi ritorna. Funziona in modo simile al selettore di danza in cui contiene istruzioni xper garantire che l'IP si sposti solo a destra o sinistra.

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

Genera 200ms di danza

Questo è un altro che inizia con x. Sarà diviso in due sezioni: <(")>e un'altra (>")> and <("<), perché sono due sezioni distinte ed xè l'unica cosa che condividono.

<(")>

>:2* _"><"b2.

Questo fondamentalmente fa l'inizio della generate 100ms danceroutine, ma popola le mani degli uccelli come ><invece di una ^vcombinazione casuale . Anche nquesta volta si moltiplica per due. Questo rende tutto pronto per utilizzare la generate 100ms danceroutine per produrre l'intero uccello e attendere invece 200ms.

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

(>")> e <("<)

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

Questa piccola spiegazione riguarda la generazione (>")>e <("<), sebbene xpossa inviare l'IP al di fuori di esso (spiegato di seguito).

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 byte

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

Sto usando i millisecondi dall'epoca per generare un numero casuale. Teoricamente, questo genererebbe sempre lo stesso (set di) numero (i), ma un test sul mio PC mi ha dato un risultato piuttosto casuale (la maggior parte dei numeri è apparsa più o meno allo stesso modo). Anche usando il fatto che gli elementi html con un id vengono aggiunti all'oggetto finestra globale in JavaScript, quindidocument.getElementById() non è necessario.

HTML: 8 byte

<b id=a>

Sto omettendo le virgolette qui e non sto chiudendo il btag. Non è html valido, ma tutti i browser chiudono comunque automaticamente il tag. L'ho reso audace perché bè un elemento HTML a un carattere e perché la danza del mio uccello merita di essere notata.

PowerShell , 124 117 byte

(Grazie TimmyD )

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

Provalo online! (Non che funzionerà in TIO ...)

Noodel , 67 byte non competitivi

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

Questa sfida è stata molto difficile per Noodel perché non ha operatori aritmetici intelligenti o comparativi. Ma dopo aver fatto questa sfida, penso che Noodel sia pronto per la sua prima uscita.

Provalo:)

Come funziona

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

Ecco una versione che funziona come uno snippet di codice.

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

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

Ho anche provato a farlo senza l'arte ascii del pollo, ma è stato molto più lungo.

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

Rubino, 97 + 1 = 98 byte

+1 byte dalla -nbandiera.

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

Clojure, 185 178 byte

+18 byte perché non iniziava <(")> .

-7 byte mediante allineamento birdse eliminazione di 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)))

Dividi semplicemente gli uccelli sugli spazi, seleziona un indice casuale da 0 a 6, visualizza l'uccello scelto, quindi se l'indice scelto è maggiore di 2, attende 100 ms, altrimenti 200 ms.

Clojure ha davvero bisogno di un splitmetodo di stringa nel core.

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