Este es mi primer desafío, así que lo mantengo bastante simple.

Si alguna vez escribiste telnet towel.blinkenlights.nlen tu línea de comando y presionaste enter, habrás experimentado la alegría de la asciimación. Asciimation es, simplemente, hacer una animación con ascii art. Hoy haremos una asciimación muy básica de una persona que hace saltos.

Habrá dos imágenes ascii que reuniremos en una sola asciimación. Numero 1:

_o_
 0
/ \

Número 2:

\o/
_0_
<blank line>

Tenga en cuenta que el segundo tiene una línea en blanco al final.

Entonces su programa debe hacer estos pasos:

1. Borrar la pantalla de la consola.
2. Imprima la imagen correcta de arte ascii.
3. Establezca una bandera o algo para que sepa hacer la otra imagen la próxima vez.
4. Espera un momento (aproximadamente un segundo).
5. Continuar en 1.

Reglas

• Su programa debe ser un bucle infinito (teóricamente).
• El lenguaje de programación que usa debe haberse creado antes de que se publique este desafío.
• Este es el código de golf , por lo que gana el código más corto en bytes.
• Se aplican lagunas estándar.

¡Disfrutar!

CJam, 51 45 42 38 36 bytes

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

Lo anterior usa notación de intercalación; la secuencia ^[es en realidad el carácter ASCII con el punto de código 27.

Tomé prestada la secuencia de escape ( ^[c) de la respuesta de @DomHastings ( con su permiso ) para guardar 4 bytes.

Verificación

Puede recrear el archivo de esta manera:

base64 -d > jj.cjam <<< ImNcby8KXzBfIiIbY19vXwogMAovIFwbIntfb1w2ZTRtIX1n

Para ejecutar el código, descargue el intérprete de CJam y ejecute esto:

java -jar cjam-0.6.5.jar jj.cjam

Esto funcionará en cualquier terminal que sea compatible con console_codes o un subconjunto apropiado. ¹

Cómo 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.

¹ _{Los saltos se verán mejor si oculta el cursor del terminal antes de ejecutar el programa. En Konsole, por ejemplo, puede establecer el color del cursor para que coincida con el color de fondo. Esto debe hacerse a través de la configuración de su terminal, ya que ^[crestablece el terminal.}

Pyth - 41 40 39 bytes

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

(Estoy contando los \x1b's como un byte ya que SO destruye caracteres especiales).

Claramente no funciona en línea ya que es a) un bucle infinito yb) 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.

Me sorprendió descubrir que la asignación aumentada funcionaba con la asignación posterior. Pyth es asombroso.

QBasic, 58 bytes

Probado en QB64 .

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

El lenguaje correcto para el problema puede ser sorprendentemente competitivo, incluso si generalmente es detallado. El ?atajo para PRINTayuda también, por supuesto. CLSes cl ear s creen; RUNsin argumentos reinicia el programa, que es la forma más corta de obtener un bucle infinito.

El único otro truco aquí es imprimir 0para la sección media de la primera imagen. QBasic pone un espacio delante (y después) de valores numéricos no negativos cuando los imprime, lo que da como resultado 0 . Guardado 3 personajes más " 0".

También puedo señalar que la demora en este código es, literalmente, un segundo , y no depende de la máquina. ; ^ P

Perl (* nix) , 54 bytes

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

( \x1bse cuenta como 1 byte pero escapó para una prueba más fácil). ¡Lo anterior se ha probado con Bash y se ha acortado otro byte gracias a @Dennis !

Perl (Windows) , 56 bytes

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

¡Gracias a @Jarmex por sus pruebas y consejos!

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

Bastante sencillo. Utiliza cadenas de plantillas para almacenar las imágenes y alterna un valor booleano para determinar cuál usar.

NOTA: Esta solución puede no ser válida, ya que en realidad no usa una consola. Sin embargo, no creo que sea posible borrar una consola del navegador usando JS, al menos no mientras se usa 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

Se ejecuta en 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, agregue dos 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")
}

Buen entrenamiento: D Solo me preguntaba si esto era factible. Sin embargo, no hay precios que ganar ...;)

Si alguien quiere probar esto: después de ejecutar el programa, debe presionar Ctrl + D (final de la entrada) para iniciar realmente el bloque END. Para terminarlo tengo que usar Ctrl + Z.

También tengo esto, que solo tiene 74 bytes, pero comienza con una pausa de un segundo, que no es el comportamiento deseado, creo

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

Lote - 82 bytes

Editar: silencia el comando de tiempo de espera y elimina la nueva línea adicional.

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

He visto otras 2 respuestas de lotes similares, así que realmente no quería publicar esto, pero este es mi primer golf.

BBC BASIC, 75 bytes

Tenga en cuenta que la tokenización lo reduce a 75 bytes. El espacio en blanco lo agrega el 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)})()

Inicia sesión en la consola. Probado en 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

(en Windows , reemplazando clearcon cls, gracias a undergroundmonorail)

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

En Linux, 72 bytes

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

Esto usa nuevas líneas reales en lugar de \nguardar un byte; de lo contrario, ies 1 o -1 como "bandera" y utiliza la recursividad para lograr el bucle infinito. Llámalo como cualquieran(1) o solon() .

Además, run(`clear`)/ run(`cls`)utiliza un comando de shell para borrar la ventana, porque Julia no tiene un comando incorporado de limpieza de ventana.

Lote de Windows, 83 89

Editar eliminó la línea vacía después de la aclaración por OP

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

Si se deshace de la línea vacía en el hombre que salta (eso no se puede ver de todos modos), la puntuación es 83

Nota: timeoutno está presente en Windows XP. Funciona en Vista o versiones más recientes. Además, timeoutno es preciso para el segundo, por lo que es una opción perfecta para implementar el paso 4 (Espere un momento ( aproximadamente un segundo ))

Javascript (ES6), 82 bytes

Una modificación de mi respuesta anterior que usa la consola. Funciona parcialmente en Firefox, pero solo borra la consola en Chrome, AFAIK.

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

Como siempre, las sugerencias son bienvenidas!

JavaScript, 92 91 89 bytes

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

• Sin funciones ES6 (pero sería significativamente más corto con ellas)
• Funciona con Node.js en Linux (no sé sobre otros entornos)
• Funciona parcialmente en la consola de Chrome ( cse muestra en lugar de limpiar la consola, interrumpiendo la salida)

Eliminando "\033c"+el código anterior, lo siguiente funciona en el navegador, pero no borra la consola.

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}

Requiere códigos de escape.

Adelante, 86 bytes

Requiere GNU Forth para las cadenas escapadas. Para ejecutar en un Forth no GNU, simplemente cambie S\"a S", y los caracteres escapados no se imprimirán correctamente.

: 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

Lo anterior requiere alguna explicación, ya que el marcado de Stack Exchange no representa correctamente los caracteres PETSCII:

• El programa se muestra aquí por conveniencia en minúsculas, pero puede y debe ingresarse y ejecutarse en modo mayúscula en un Commodore 64.
• El primer y tercer caracteres "S" están en realidad en video inverso, y se producen presionando la CLRtecla ( SHIFT+ HOME).
• Los caracteres "q" están en realidad en video inverso, y se producen presionando el cursor hacia abajo (CRSR ⇓ ).
• El "|" los caracteres están realmente en video inverso, y se producen presionando el cursor izquierdo ( SHIFT+ CRSR ⇒).

cera de abejas ,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   <

Explicación de las partes importantes del 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

Los f's empujan los valores en el gstack (pila global) para su uso posterior. Se accede a estos valores mediante las instrucciones 0gh(o las duplicadas hg0) y hg( gh). hgira el gstack hacia arriba, glee el valor superior de gstack y lo empuja al lstack (pila local) de la abeja (puntero de instrucción).

}`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'-<

Una explicación en profundidad sigue más adelante, si es necesario. Quizás con animación.

Deadfish , no competidor (658 bytes)

iiisisdddddoiiiiiiiiiiiiiiiioddddddddddddddddodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddoddddsddddoiiiiiiiiiiiiiiiioddddddddddddddddoddddddddddddddddddddddodddsddodddddddddddddddoddddddddddddddddddddddsddddddddoddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddoosddddddddoiiiiiiiiiiiiiiiiiiioddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddodddddddddddddddddddddddddddddddddddddosdddddodddddddddddddddddddddddddddddddddddddddddddddddoddddddddddddddddddddddddddddddddddddddsdddddodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddoo

Esta es una solución no competitiva , ya que no cumple completamente con los requisitos del desafío. Deadfish es un idioma interpretado muy extraño, que solo tiene 4 comandos y un acumulador. El acumulador es una variable de un solo byte inicializada en 0. Los 4 comandos son:

• i = Incrementar el acumulador a = a + 1
• d = Disminuir el acumulador a = a - 1
• s = Cuadrar el acumulador a = a * a
• o = Salida del acumulador print(a)

Como el lenguaje no incluye repetición, borrar la pantalla o retrasos, no cumple con los requisitos. Rendimiento esperado:

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

Explicación del 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

Intérprete de Deadfish en 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 no competitivos

Sin competencia porque Noodel nació después de que se creó el desafío :)

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

Intentalo:)

Cómo 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.

Actualmente no hay una versión de Noodel que admita la sintaxis utilizada en este desafío. Aquí hay una versión que hace:

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>