Questa è la mia prima sfida, quindi la sto mantenendo abbastanza semplice.

Se hai mai digitato telnet towel.blinkenlights.nlsulla riga di comando e hai premuto Invio, avrai sperimentato la gioia dell'asciugatura. Asciimation sta facendo semplicemente un'animazione con l'arte ascii. Oggi faremo un'essiccazione di base di una persona che fa jacks.

Ci saranno due immagini ASCII che metteremo insieme in un'unica asciugatura. Numero 1:

_o_
 0
/ \

Numero 2:

\o/
_0_
<blank line>

Si noti che il secondo ha una riga vuota alla fine.

Quindi il tuo programma dovrebbe eseguire questi passaggi:

1. Cancella lo schermo della console.
2. Stampa l'immagine ascii art corretta.
3. Imposta una bandiera o qualcosa in modo che tu sappia fare l'altra immagine la prossima volta.
4. Aspetta un attimo (circa un secondo).
5. Continua su 1.

Regole

• Il tuo programma deve essere un ciclo infinito (teoricamente).
• Il linguaggio di programmazione che usi deve essere stato creato prima di pubblicare questa sfida.
• Questo è code-golf , quindi vince il codice più breve in byte.
• Si applicano scappatoie standard.

Godere!

CJam, 51 45 42 38 36 byte

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

Quanto sopra usa la notazione con il cursore; la sequenza ^[è in realtà il carattere ASCII con il punto di codice 27.

Ho preso in prestito la sequenza di escape ( ^[c) dalla risposta di @DomHastings ( con il suo permesso ) per salvare 4 byte.

Verifica

Puoi ricreare il file in questo modo:

base64 -d > jj.cjam <<< ImNcby8KXzBfIiIbY19vXwogMAovIFwbIntfb1w2ZTRtIX1n

Per eseguire il codice, scarica l' interprete CJam ed esegui questo:

java -jar cjam-0.6.5.jar jj.cjam

Funzionerà su qualsiasi terminale che supporti console_codes o un sottoinsieme appropriato. ¹

Come funziona

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.

¹ _{Le prese saltanti avranno un aspetto migliore se si nasconde il cursore del terminale prima di eseguire il programma. In Konsole, ad esempio, puoi impostare il colore del cursore in modo che corrisponda al colore di sfondo. Questo deve essere fatto tramite le impostazioni del terminale, poiché ^[cripristina il terminale.}

Pyth - 41 40 39 byte

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

(Sto contando \x1bcome un byte poiché SO distrugge i caratteri speciali).

Chiaramente non funziona online poiché è a) un ciclo infinito eb) usa i codici di escape del terminale.

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

Sono stato sorpreso di scoprire che l'assegnazione aumentata ha funzionato con post-assegnazione. Pyth è fantastico.

QBasic, 58 byte

Testato su QB64 .

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

La lingua giusta per il problema può essere sorprendentemente competitiva, anche se di solito è prolissa. Anche la ?scorciatoia per PRINTaiuta, ovviamente. CLSè cl orecchio s creen; RUNsenza argomenti riavvia il programma, che è il modo più breve per ottenere un ciclo infinito.

L'unico altro trucco qui è la stampa 0per la sezione centrale della prima immagine. QBasic mette uno spazio davanti a (e dopo) valori numerici non negativi quando li stampa, risultando in 0 . Hai salvato 3 caratteri " 0".

Posso anche sottolineare che il ritardo in questo codice è letteralmente un secondo e non dipende dalla macchina. ; ^ P

Perl (* nix) , 54 byte

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

( \x1bviene conteggiato come 1 byte ma è sfuggito per un test più semplice.) Quanto sopra è stato testato con Bash e accorciato di un altro byte grazie a @Dennis !

Perl (Windows) , 56 byte

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

Grazie a @Jarmex per i suoi test e consigli!

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

Abbastanza semplice. Utilizza stringhe di modello per memorizzare le immagini e attiva / disattiva un valore booleano per determinare quale utilizzare.

NOTA: questa soluzione potrebbe non essere valida, poiché in realtà non utilizza una console. Tuttavia, non credo che sia possibile cancellare una console del browser utilizzando JS, almeno non durante l'utilizzo di Firefox.

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

<pre id=O>

Bash, 86 84 byte

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 byte

Funziona su 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

Per i computer UNIX, aggiungere due byte:

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

Bel allenamento: D Mi chiedevo solo se fosse fattibile. Nessun prezzo da guadagnare però ...;)

Se qualcuno vuole verificarlo: dopo aver eseguito il programma è necessario premere Ctrl + D (fine dell'input) per avviare effettivamente il blocco END. Per terminarlo devo usare Ctrl + Z.

Ho anche questo, che è solo 74 byte, ma inizia con una pausa di un secondo che non è il comportamento desiderato, penso

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

Lotto - 82 byte

Modifica: silenzia il comando di timeout e rimuove la nuova riga aggiuntiva.

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

Ho visto altre 2 risposte batch simili quindi non volevo davvero postare questo, ma questo è il mio primo golf in assoluto.

BBC BASIC, 75 byte

Si noti che la tokenizzazione lo abbassa a 75 byte. Lo spazio bianco viene aggiunto dall'IDE.

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

JavaScript ES6, 100 95 byte

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

Accede alla console. Testato su Safari Nightly

Lotto, 151 130 118 byte

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 byte

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

Julia, 70 byte

(su Windows , sostituendo clearcon cls, grazie a undergroundmonorail)

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

Su Linux, 72 byte

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

Questo utilizza le nuove righe effettive anziché \nsalvare un byte; in caso contrario, iè 1 o -1 come "flag" e utilizza la ricorsione per ottenere il ciclo infinito. Chiamalo come uno n(1)o solo n().

Inoltre, run(`clear`)/ run(`cls`)usa un comando shell per cancellare la finestra, perché Julia non ha un comando di cancellazione della finestra incorporato.

Windows Batch, 83 89

Modifica rimosso la riga vuota dopo il chiarimento da parte di OP

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

Se ti sbarazzi della linea vuota nell'uomo che salta (che non può essere visto comunque), il punteggio è 83

Nota: timeoutnon è presente in Windows XP. Funziona con Vista o versioni più recenti. Inoltre timeoutnon è preciso al secondo, quindi è una scelta perfetta per implementare il passaggio 4 (Aspetta un attimo ( circa un secondo ))

Javascript (ES6), 82 byte

Una modifica della mia risposta precedente che utilizza la console. Funziona parzialmente in Firefox, ma cancella solo la console in Chrome, AFAIK.

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

Come sempre, suggerimenti benvenuti!

JavaScript, 92 91 89 byte

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

• Nessuna funzionalità ES6 (ma sarebbe significativamente più breve con loro)
• Funziona con Node.js su Linux (non conosco altri ambienti)
• Funziona parzialmente nella console di Chrome ( cviene mostrato invece di cancellare la console, interrompendo l'output)

Rimuovendo "\033c"+dal codice sopra, nel browser funziona quanto segue, ma non cancella la console.

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

Rubino, 79 byte

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

Richiede codici di escape.

Avanti, 86 byte

Richiede GNU Forth per le stringhe di escape. Per eseguire in un Forth non GNU, basta cambiare S\"in S", e i caratteri di escape non verranno stampati correttamente.

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

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

Quanto sopra richiede alcune spiegazioni, poiché il markup di Stack Exchange non rappresenta correttamente i caratteri PETSCII:

• Il programma è mostrato qui per comodità in minuscolo, ma può e deve essere inserito ed eseguito in modalità maiuscola su un Commodore 64.
• Il primo e il terzo carattere "S" sono in realtà in video inverso e prodotti premendo il CLRtasto ( SHIFT+HOME ).
• I caratteri "q" sono in realtà in video inverso e prodotti premendo il cursore giù (CRSR ⇓ ).
• Il "|" i personaggi sono in realtà in video inverso e prodotti premendo il cursore sinistro ( SHIFT+ CRSR ⇒).

cera d'api ,119 113 byte

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   <

Spiegazione delle parti importanti del programma:

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

I f's spingono i valori sul gstack (stack globale) per un uso successivo. Questi valori sono accessibili dalle istruzioni 0gh(o speculari hg0) e hg( gh). hruota il gstack verso l'alto, glegge il valore massimo di gstack e lo spinge sul lstack (stack locale) dell'ape (puntatore alle istruzioni).

}`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 spiegazione approfondita segue più avanti, se necessario. Magari con l'animazione.

Pesce morto , non competitivo (658 byte)

iiisisdddddoiiiiiiiiiiiiiiiioddddddddddddddddodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddoddddsddddoiiiiiiiiiiiiiiiioddddddddddddddddoddddddddddddddddddddddodddsddodddddddddddddddoddddddddddddddddddddddsddddddddoddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddoosddddddddoiiiiiiiiiiiiiiiiiiioddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddodddddddddddddddddddddddddddddddddddddosdddddodddddddddddddddddddddddddddddddddddddddddddddddoddddddddddddddddddddddddddddddddddddddsdddddodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddoo

Questa è una soluzione non competitiva , in quanto non soddisfa completamente i requisiti della sfida. Deadfish è un lanugage interpretato molto strano, che ha solo 4 comandi e un accumulatore. L'accumulatore è una variabile a byte singolo inizializzata su 0. I 4 comandi sono:

• i = Incrementa l'accumulatore a = a + 1
• d = Decrementa l'accumulatore a = a - 1
• s = Quadrare l'accumulatore a = a * a
• o = Uscita dell'accumulatore print(a)

Poiché la lingua non include ripetizioni, svuota lo schermo o ritardi, non soddisfa i requisiti. Uscita prevista:

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

Spiegazione del codice:

_  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

Interprete Deadfish in 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 byte non competitivi

Non competitivo perché Noodel è nato dopo la creazione della sfida :)

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

Provalo:)

Come funziona

”ṛ|ọ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.

Al momento non esiste una versione di Noodel che supporti la sintassi utilizzata in questa sfida. Ecco una versione che fa:

24 byte

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