Este é o meu primeiro desafio, por isso estou mantendo-o bastante simples.

Se você já digitou telnet towel.blinkenlights.nlsua linha de comando e pressionou enter, terá experimentado a alegria da asciimação. A asciimação é, simplesmente, fazer uma animação com arte ascii. Hoje estaremos fazendo uma estimativa muito básica de uma pessoa fazendo polichinelos.

Haverá duas imagens ascii que reuniremos em uma asciimação. Número 1:

_o_
 0
/ \

Número 2:

\o/
_0_
<blank line>

Observe que o segundo tem uma linha em branco no final.

Portanto, seu programa deve executar estas etapas:

1. Limpe a tela do console.
2. Imprima a imagem correta da arte ascii.
3. Defina uma bandeira ou algo assim para que você faça a outra imagem da próxima vez.
4. Aguarde um momento (cerca de um segundo).
5. Continue na 1.

Regras

• Seu programa deve ser um loop infinito (teoricamente).
• A linguagem de programação usada deve ter sido criada antes da publicação deste desafio.
• Isso é código-golfe , então o código mais curto em bytes vence.
• Aplicam-se brechas padrão.

Apreciar!

CJam, 51 45 42 38 36 bytes

"c\o/
_0_""^[c_o_
 0
/ \^["{_o\6e4m!}g

O acima usa notação de sinal de intercalação; a sequência ^[é realmente o caractere ASCII com o ponto de código 27.

Peguei emprestada a sequência de escape ( ^[c) da resposta do @DomHastings ( com a permissão dele ) para salvar 4 bytes.

Verificação

Você pode recriar o arquivo assim:

base64 -d > jj.cjam <<< ImNcby8KXzBfIiIbY19vXwogMAovIFwbIntfb1w2ZTRtIX1n

Para executar o código, baixe o interpretador CJam e execute:

java -jar cjam-0.6.5.jar jj.cjam

Isso funcionará em qualquer terminal que suporte console_codes ou um subconjunto apropriado. ¹

Como funciona

e# Push both jumping jacks on the stack.

"c\o/
_0_"

"^[c_o_
 0
/ \^["

e# When chained together, they contain two occurrences of the string "\ec",
e# which resets the terminal. Encoding the ESC byte in the second string
e# eliminates the need two escape a backslash before the string terminator.

{         e# Do:
  _o      e#   Copy the jumping jack on top of the stack and print the copy.
  \       e#   Swap the order of the jumping jacks.
  6e4m!   e#   Calculate the factorial of 60,000 and discard the result.
          e#   This takes "about a second".
}g        e# Since the discarded factorial was non-zero, repeat the loop.

¹ _{As tomadas de salto terão uma aparência melhor se você ocultar o cursor do terminal antes de executar o programa. No Konsole, por exemplo, você pode definir a cor do cursor para corresponder à cor do plano de fundo. Isso deve ser feito através das configurações do seu terminal, pois ^[credefine o terminal.}

Pitão - 41 40 39 bytes

.VZ"\x1b[H\x1b[J"@c"_o_
 0
/ \\\o/
_0_"Tb .p9

(Estou contando os \x1bbytes como um byte, pois o SO destrói caracteres especiais).

Claramente não funciona on-line, pois é a) um loop infinito eb) usa códigos de escape de terminal.

#                Infinite loop
 "..."           Print escape sequences to clear screen
 @               Modular indexing
  c     T        Chop at index ten into the constituent frames
   "..."         Frames 1 & 2 concatenated (Pyth allows literal newlines in strings)
  ~              Post assign. This is an assign that returns the old value.
   h             Increment function. Putting it after an assign makes it augmented assign.
   Z             Variable auto-initialized to zero.
 .p9             Permutations(range(9), 9). Takes about a second on my machine.

Fiquei surpreso ao descobrir que a atribuição aumentada funcionava com a pós-atribuição. Pyth é incrível.

QBasic, 58 bytes

Testado em QB64 .

CLS
?"_o_"
?0
?"/ \"
SLEEP 1
CLS
?"\o/"
?"_0_"
SLEEP 1
RUN

O idioma certo para o problema pode ser surpreendentemente competitivo, mesmo que seja geralmente detalhado. O ?atalho para PRINTajuda também, é claro. CLSé Cl orelha s creen; RUNsem argumentos reinicia o programa, que é a maneira mais curta de obter um loop infinito.

O único outro truque aqui é imprimir 0para o meio da primeira foto. QBasic coloca um espaço na frente de (e depois) valores numéricos não negativos quando os imprime, resultando em 0 . Salvo 3 caracteres " 0".

Também posso salientar que o atraso neste código é literalmente um segundo e não depende da máquina. ; ^ P

Perl (* nix) , 54 bytes

sleep print"\x1bc",$-++%2?'\o/
_0_
':'_o_
 0
/ \
'while 1

( \x1bé contado como 1 byte, mas escapou para testes mais fáceis.) O item acima foi testado com Bash e reduzido por outro byte, graças a @Dennis !

Perl (Windows) , 56 bytes

sleep print"\x1b[2J",$-++%2?'\o/
_0_
':'_o_
 0
/ \
'while 1

Obrigado a @Jarmex por seus testes e conselhos!

Javascript (ES6), 109 93 79 70 bytes + HTML, 12 10 bytes = 120 106 91 80 bytes

Bastante direto. Usa seqüências de caracteres de modelo para armazenar as imagens e alterna um valor booleano para determinar qual usar.

NOTA: Esta solução pode não ser válida, pois na verdade não usa um console. No entanto, não acredito que seja possível limpar um console do navegador usando JS, pelo menos não enquanto estiver usando o Firefox.

a=!1,setInterval(_=>O.innerHTML=(a=!a)?`_o_ 
 0
/ \\`:`\\o/ 
_0_`,1e3)

<pre id=O>

Bash, 86 84 bytes

while sleep 1;do printf "\e[2J_o_\n 0\n/ \\";sleep 1;printf "\r\e[2J\o/\n_0_\n";done

Python 2, 99 bytes

Executa no Windows

import os,time
g=0
while 1:os.system("cls");print["\\o/\n_0_","_o_\n 0 \n/ \\"][g];time.sleep(1);g=~g

Para máquinas UNIX, adicione dois bytes:

import os,time
g=0
while 1:os.system("clear");print["\\o/\n_0_","_o_\n 0 \n/ \\"][g];time.sleep(1);g=~g

awk - 95 92 86 84 83

END{
    for(;++j;)
        system("clear;printf '"(j%2?"_o_\n 0\n/ \\":"\\o/\n_0_")"';sleep 1")
}

Bom treino: D Apenas me perguntei se isso era possível. Ainda não há preços a ganhar ...;)

Se alguém quiser testar isso: depois de executar o programa, você deve pressionar Ctrl + D (fim da entrada) para realmente iniciar o bloco END. Para finalizar, eu tenho que usar Ctrl + Z.

Eu também tenho isso, que tem apenas 74 bytes, mas começa com a pausa de um segundo, que não é o comportamento desejado, eu acho

END{
    for(;1;print++j%2?"_o_\n 0\n/ \\":"\\o/\n_0_")
        system("sleep 1;clear")
}

Lote - 82 bytes

Editar: silenciou o comando timeout e removeu a nova linha extra.

cls&echo _o_&echo  0&echo / \&timeout>nul 1&cls&echo \o/&echo _0_&timeout>nul 1&%0

Eu já vi duas outras respostas em lotes semelhantes, então eu realmente não queria postar isso, mas este é o meu primeiro golfe.

BBC BASIC, 75 bytes

Observe que a tokenização reduz para 75 bytes. O espaço em branco é adicionado pelo IDE.

      g=0
   10 IFg=0THENPRINT"\o/":PRINT"_0_"ELSEPRINT"_o_":PRINT" 0 ":PRINT"/ \"
      g=1-g:WAIT 100CLS:GOTO10

JavaScript ES6, 100 95 bytes

(f=_=>{console.log(_?`_o_
 0
/ \\`:`\\o/
_0_`)
(b=setTimeout)(q=>(clear(),b(b=>f(!_))),1e3)})()

Registra no console. Testado no Safari Nightly

Lote, 151 130 118 bytes

cls
@echo _o_
@echo  0
@echo / \
@PING -n 2 127.0.0.1>NUL
cls
@echo \o/
@echo _0_
@PING -n 2 127.0.0.1>NUL
%0

CBM 64 BASIC V2, 121 119 112 117 bytes

2?CHR$(147)+"\o/":?" 0":?"/ \"
3GOSUB7
4?CHR$(147)+"_o_":?"_0_"
5GOSUB7
6RUN
7A=TI
8IFTI-A<60THENGOTO8
9RETURN

Julia, 70 bytes

(no Windows , substituindo clearpor cls, graças ao undergroundmonorail)

n(i=1)=(sleep(1);run(`cls`);print(i>0?"_o_
 0
/ \\":"\\o/
_0_");n(-i))

No Linux, 72 bytes

n(i=1)=(sleep(1);run(`clear`);print(i>0?"_o_
 0
/ \\":"\\o/
_0_");n(-i))

Isso usa novas linhas reais em vez de \nsalvar um byte; caso contrário, ié 1 ou -1 como o "sinalizador" e usa a recursão para obter o loop infinito. Chame-o como um n(1)ou apenas n().

Além disso, run(`clear`)/ run(`cls`)usa um comando shell para limpar a janela, porque Julia não possui um comando de limpeza de janela interno.

Lote do Windows, 83 89

Editar removeu a linha vazia após o esclarecimento pelo OP

@cls&echo _o_&echo  0&echo./ \&timeout>nul 1&cls&echo \o/&echo _0_&timeout>nul 1&%0

Se você se livrar da linha vazia no homem pulando (que não pode ser vista de qualquer maneira), a pontuação é 83

Nota: timeoutnão está presente no Windows XP. Funciona no Vista ou em versões mais recentes. Além disso, timeoutnão é preciso para o segundo, por isso é uma escolha perfeita para implementar a etapa 4 (aguarde um momento ( cerca de um segundo ))

Javascript (ES6), 82 bytes

Uma modificação da minha resposta anterior que usa o console. Funciona parcialmente no Firefox, mas apenas limpa o console no Chrome, AFAIK.

a=!0,c=console,setInterval(_=>c.log(c.clear(a=!a)|a?`_o_
 0
/ \\`:`\\o/
_0_`),1e3)

Como sempre, sugestões são bem-vindas!

JavaScript, 92 91 89 bytes

x=0;setInterval(function(){console.log("\033c"+["_o_\n 0\n/ \\","\\o/\n_0_"][x^=1])},1e3)

• Não há recursos do ES6 (mas seria significativamente menor com eles)
• Funciona com o Node.js no Linux (não conhece outros ambientes)
• Funciona parcialmente no console do Chrome ( cé mostrado em vez de limpar o console, interrompendo a saída)

Removendo "\033c"+do código acima, o seguinte funciona no navegador, mas não limpa o console.

x=0;setInterval(function(){console.log(["_o_\n 0\n/ \\","\\o/\n_0_"][x^=1])},1e3)

Ruby, 79 bytes

k=!0;loop{puts((k)?"\e[H\e[2J_o_\n 0\n/ \\":"\e[H\e[2J\\o/\n_0_");k=!k;sleep 1}

Requer códigos de escape.

Quarto, 86 bytes

Requer GNU Forth para as seqüências de escape. Para rodar em um não-GNU Forth, basta mudar S\"para S", e os caracteres de escape não serão impressos corretamente.

: P PAGE TYPE CR 999 MS ;
: R BEGIN S\" \\o/\n_0_" P S\" _o_\n 0 \n/ \\" P 0 UNTIL ; R

CBM BASIC v2.0 (68 caracteres)

0?"S_o_q||0q||N M":goS1:?"SMoN":?"_0_":goS1:gO
1wA161,255,pE(161):reT

O exposto acima requer algumas explicações, pois a marcação no Stack Exchange não representa adequadamente os caracteres PETSCII:

• O programa é mostrado aqui por conveniência em letras minúsculas, mas pode e deve ser inserido e executado no modo maiúsculas em um Commodore 64.
• O primeiro e o terceiro caracteres "S" estão realmente em vídeo reverso e produzidos pressionando a CLRtecla ( SHIFT+ HOME).
• Os caracteres "q" estão no vídeo reverso e são produzidos pressionando o cursor para baixo ( CRSR ⇓).
• O "|" os caracteres estão realmente no vídeo reverso e são produzidos pressionando o cursor esquerdo ( SHIFT+ CRSR ⇒).

cera de abelha ,119 113 bytes

ph0`J2[`}ghq'-<gh0N}`0`}gN`/o\`Ngh0`J`<
>g}`o`}N` `0>'d`0 `N`/ \`0hg>-'phg}`[2`b
dF1f+5~Zzf(.FP9f..F3_#     d   <

Explicação das partes importantes do programa:

left to right  right to left

3FBf   or       fBF3          27       ASCII code for (esc)
3             [x,x,3]•        set lstack 1st to 3
 F            [3,3,3]•        set lstack to 1st
  B           [3,3,27]•       1st=1st^2nd
   f                          push lstack 1st on gstack
——————
9PF.(f   or    f(.FP9         102400   counter to roughly match a wait time
                                       of 1 s on my i5 2410M Laptop
9             [x,x,9]•        set lstack 1st to 9
 P            [x,x,10]•       increment 1st
  F           [10,10,10]•     set lstack to 1st
   .          [10,10,100]•    1st=1st*2nd
    (         [10,10,102400]• 1st=1st<<2nd (100<<10=102400, arithmetic shift left)
     f                        push lstack 1st on gstack
——————
zZ~5+f   or    f+5~Zz         95       ASCII for '_'
z             [0,0,0]•        initialize lstack to zero
 Z            [0,0,90]•       get value from relative coordinate (0,0),
                              which is the location of `Z` itself, ASCII(Z)=90
  ~           [0,90,0]•       flip 1st and 2nd lstack values
   5          [0,90,5]•       set lstack 1st to 5 
    +         [0,90,95]•      1st = 1st+2nd
     f                        push lstack 1st on gstack

Eles fpressionam os valores no gstack (pilha global) para uso posterior. Esses valores são acessados ​​pelas instruções 0gh(ou espelhadas hg0) e hg( gh). hgira o gstack para cima, glê o valor máximo do gstack e o empurra para o lstack (pilha local) da abelha (ponteiro de instruções).

}`o`}N` 0 `N`/ \`                      sequence to print the standing man

N`\o/`Ng}`0`}N                         sequence to print the jumping man

}`[2J`                        equivalent to the ANSI escape sequence (esc)[2J
                              to clear the screen
>-'p  or >-'q  or >  p        loop for counting down (wait 1 s)
d  <      b  <    d'-<

Uma explicação detalhada segue a seguir, se necessário. Talvez com animação.

Peixe morto , não competidor (658 bytes)

iiisisdddddoiiiiiiiiiiiiiiiioddddddddddddddddodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddoddddsddddoiiiiiiiiiiiiiiiioddddddddddddddddoddddddddddddddddddddddodddsddodddddddddddddddoddddddddddddddddddddddsddddddddoddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddoosddddddddoiiiiiiiiiiiiiiiiiiioddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddodddddddddddddddddddddddddddddddddddddosdddddodddddddddddddddddddddddddddddddddddddddddddddddoddddddddddddddddddddddddddddddddddddddsdddddodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddoo

Esta é uma solução não concorrente , pois não atende completamente aos requisitos de desafio. Deadfish é uma linguagem interpretada muito estranha, que possui apenas 4 comandos e um acumulador. O acumulador é uma variável de byte inicializada em 0. Os 4 comandos são:

• i = Incrementar o acumulador a = a + 1
• d = Decrementa o acumulador a = a - 1
• s = Esquadrar o acumulador a = a * a
• o = Saída do acumulador print(a)

Como o idioma não inclui repetição, limpeza da tela ou atrasos, ele não atende aos requisitos. Saída esperada:

_o_
 0 
/ \
(Blank line, not from the program)
\o/
_0_
(Blank line, not from the program)
(Blank line, not from the program)

Explicação do código:

_  iiisisdddddo
o  iiiiiiiiiiiiiiiio
_  ddddddddddddddddo
\n dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddo
   ddddsddddo
0  iiiiiiiiiiiiiiiio
   ddddddddddddddddo
\n ddddddddddddddddddddddo
/  dddsddo
   dddddddddddddddo
\  ddddddddddddddddddddddsddddddddo
\n ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddo
\n o
\  sddddddddo
o  iiiiiiiiiiiiiiiiiiio
/  ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddo
\n dddddddddddddddddddddddddddddddddddddo
_  sdddddo
0  dddddddddddddddddddddddddddddddddddddddddddddddo
_  ddddddddddddddddddddddddddddddddddddddsdddddo
\n dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddo
\n o

Interpretador de peixes mortos em Python 3:

c=input()
o=""
a=0
for p in range(0,len(c)):
    i=c[p]
    if i=="i":
        a += 1
    if i=="d":
        a+=-1
    if i=="s":
        a=a*a
    if i=="o":
        o+=chr(a)
print(o)

Noodel , 24 bytes não- concorrentes

Incompetente porque Noodel nasceu depois que o desafio foi criado :)

”ṛ|ọBCḊCBCḣ“\o/¶_0_ḷėçḍs

Tente:)

Como funciona

”ṛ|ọBCḊCBCḣ              # Creates a string that gets decompressed into "_o_¶¤0¤¶/¤\" and places it into the pipe.
           “\o/¶_0_      # Creates a string and places it into the pipe.
                   ḷ     # Unconditionally loop the code up to a new line or end of program.
                    ė    # Takes what is in the front of the pipe and puts it into the back.
                     ç   # Clears the screen and prints.
                      ḍs # Delays for one second.

Atualmente, não existe uma versão do Noodel que suporte a sintaxe usada neste desafio. Aqui está uma versão que faz:

24 bytes

\o/¶_0_ _o_¶¤0¤¶/¤\ḷçėḍs

<div id="noodel" code="\o/¶_0_ _o_¶¤0¤¶/¤\ḷçėḍs" input="" cols="5" rows="5"></div>

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