<("<) Dançarino de pássaros (>")>

22

Seu pássaro está ansioso por algum exercício e está cansado de ficar preso em posições estáticas o tempo todo. Escreva um programa que mostre um pássaro ascii dançando aleatoriamente, atualizando a cada 100ms * n ou 200ms * n, dependendo do movimento da dança. O pássaro sempre começa com o movimento da dança <(")>.

O programa deve aceitar uma entrada que é um número para multiplicar o intervalo de sono por ( n >= 0 && n <= 50).

100ms Move

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

200ms Moves

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

Detalhes Extra

  • A aleatoriedade não precisa ser uniforme, mas cada movimento de dança deve ter uma chance razoável de ocorrer (pelo menos 1 em 60 parece justo, tudo bem se o mesmo movimento ocorrer duas vezes seguidas)
  • Deve haver apenas um pássaro exibido por vez, não vários pássaros
  • Espaço em branco à direita é permitido (mas outros caracteres à direita não são)
  • Um pássaro deve ser exibido antes do sono

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

Ganhando

redstarcoder
fonte
Os olhos do pássaro são aspas duplas ou duplas?
Pavel
@Pavel, aspas duplas
redstarcoder 31/12/16
6
Bem, hoje eu aprendi que você não precisa escapar de aspas em strings de várias linhas em python.
Pavel
Se meu idioma não puder modificar as saídas, posso apenas emitir uma nova ave a cada 100/200 ms?
precisa saber é o seguinte
1
Usando Ideone , a \rfuga de Lua parece agir exatamente como a \n. Nem eu posso usar os.execute("cls")lá. @redstarcoder
devRicher

Respostas:

3

MATL , 53 bytes

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

Os movimentos são uniformemente aleatórios.

Abaixo está uma amostra executada com n = 2. Ou tente no MATL Online! (O intérprete é experimental. Se não for executado, tente pressionar "Executar" novamente ou atualizar a página).

insira a descrição da imagem aqui

Explicação

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
Luis Mendo
fonte
6

Matlab, 125 117 bytes

Infelizmente, isso não pode ser exibido no TIO, pois não há "streaming" da saída. Aqui está um gif para uma entrada 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

Obrigado @LuisMendo por -8 bytes!

flawr
fonte
5

*> <> , 103 101 bytes

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

Experimente aqui! (escrever emn pilha inicial ou você receberá um erro)

Decidi dar uma facada no meu desafio, pois não havia respostas abaixo de 100 bytes. Coloque nna pilha e pronto! Isso reutiliza o(") caracteres para salvar alguns bytes.

Explicação

Inicialização

<vD[3'(")'

Aqui armazenamos (")para 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"

Seletor de dança

1x<.5
 \

Isso é frequentemente executado para selecionar que tipo de dança vamos gerar.

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

Há um vacima xe um <à direita também. Estes fazem ox com que seja executado novamente se ele tentar mover o IP na direção errada.

Gere 100ms de dança

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

Aqui, geramos e produzimos um dos movimentos de dança de 100ms.

 \                         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 - Gere "^" ou "v"

R!"^"x"v">

Essa é uma função simples que gera "^" ou "v" e depois retorna. Funciona de maneira semelhante ao seletor de dança, onde há instruções xpara garantir que o IP se mova apenas para a esquerda ou direita.

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

Gere 200ms de dança

Este é outro que começa com x. Ele será separado em duas seções: <(")>e outra (>")> and <("<), porque são duas seções distintas e xé a única coisa que compartilham.

<(")>

>:2* _"><"b2.

Isso basicamente faz o início da generate 100ms dancerotina, mas preenche as mãos dos pássaros como em ><vez de uma ^vcombinação aleatória . Desta vez, multiplica npor dois também. Isso faz com que tudo seja configurado para utilizar a generate 100ms dancerotina para gerar o pássaro inteiro e aguardar 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<'<("<)'

Esta pequena explicação é sobre a geração (>")>e <("<), embora xpossa enviar o IP para fora dela (explicado abaixo).

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"
redstarcoder
fonte
3

JavaScript (ES6) + HTML5: 118 116 + 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)}

Estou usando os milissegundos desde a época para gerar um número aleatório. Teoricamente, isso sempre geraria o mesmo (conjunto de) número (s), mas um teste no meu PC me deu um resultado bastante aleatório (a maioria dos números apareceu mais ou menos igualmente). Também usando o fato de que elementos html com um ID são adicionados ao objeto de janela global em JavaScript, portantodocument.getElementById() não é necessário.

HTML: 8 bytes

<b id=a>

Estou omitindo as aspas aqui e não estou fechando a btag. Não é um html válido, mas todos os navegadores fecham a tag automaticamente de qualquer maneira. Tornei-o ousado porque bé um elemento HTML de um caractere e porque a dança do meu pássaro merece ser notada.

Luke
fonte
1
Quando f se chama novamente, ele não passa n novamente. Para mim, pelo menos, isso parece honrar n na primeira vez, após o que é zero (ou indefinido). Às vezes, a saída é indefinida. Deveria ser r% 7?
Chris M
Você está certo, eu esqueci de passar n. De fato, deve ser% 7. Eu contei mal a quantidade de poses de pássaros. Obrigado pela correção, está corrigido agora.
Lucas
Desculpe, continuo aumentando a contagem de bytes! Golfe legal, eu como a função aleatória e de zero divisão
Chris M
Obrigado. Encontrei uma melhoria de 4B ao editar minha resposta, o que significa que acabei salvando 2B, então está tudo certo. A divisão zero usada para salvar bytes no ES5 e versões anteriores, mas você pode omitir os parênteses com as seqüências de caracteres de modelo desde o ES6, para que não seja mais tão útil. É um restante de uma abordagem diferente (onde usei uma sequência de modelo como primeiro argumento para o setInterval).
Lucas
2

PowerShell , 124 117 bytes

(Obrigado TimmyD )

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

Experimente online! (Não que ele funcione no TIO ...)

briantist
fonte
Você pode eliminar $be usar um pseudo-ternário para descer para 117 - for(){(-split'^(")v v(")^ ^(")^ v(")v (>")> <(")> <("<)')[($i=0..6|random)];sleep -m((100,200)[$i-gt3]*$args[0]);cls}... eu acho que é mais curto; Eu ainda estou cutucando isso.
AdmBorkBork
Você continua me salvando @TimmyD (obrigado)! Eu acho que essas mudanças são significativas o suficiente para garantir sua própria resposta; não deixa muita coisa única no meu código :)
briantist
Não, são apenas pequenos ajustes no seu código. A lógica geral é exatamente a mesma. Têm-no.
AdmBorkBork 3/17/17
2

Noodel , não competitivo 67 bytes

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

Esse desafio foi muito difícil para Noodel porque não possui operadores aritméticos inteligentes ou comparativos. Mas depois de fazer esse desafio, acho que o Noodel está pronto para seu primeiro lançamento.

Tente:)

Como 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

Aqui está uma versão que funciona como um trecho 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>

tkellehe
fonte
1

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

Eu também tentei fazer isso sem a arte ascii de frango, mas isso foi muito mais longo.

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
Cormac
fonte
1

Ruby, 97 + 1 = 98 bytes

+1 byte da -nbandeira.

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

Clojure, 185 178 bytes

18 bytes porque não estava começando <(")>.

-7 bytes inlining birdse se livrando do 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)))

Apenas divide os pássaros em espaços, escolhe um índice aleatório de 0 a 6, exibe o pássaro escolhido e, se o índice escolhido for maior que 2, ele aguarda 100ms, mais 200ms.

Clojure realmente precisa de um splitmétodo de string no núcleo.

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