C'est mon premier défi, donc je reste assez simple.

Si vous avez déjà tapé telnet towel.blinkenlights.nlsur votre ligne de commande et appuyé sur Entrée, vous aurez connu la joie de l'asciimation. L'asciimation consiste, tout simplement, à faire une animation avec l'art ascii. Aujourd'hui, nous allons faire une asciimation très basique d'une personne faisant des sauts.

Il y aura deux images ascii que nous assemblerons en une seule asciimation. Numéro 1:

_o_
 0
/ \

Numéro 2:

\o/
_0_
<blank line>

Notez que le second a une ligne vide à la fin.

Votre programme doit donc effectuer ces étapes:

1. Effacez l'écran de la console.
2. Imprimez l'image d'art ascii correcte.
3. Définissez un drapeau ou quelque chose pour que vous sachiez faire l'autre image la prochaine fois.
4. Attendez un instant (environ une seconde).
5. Continuez à 1.

Règles

• Votre programme doit être une boucle infinie (théoriquement).
• Le langage de programmation que vous utilisez doit avoir été créé avant la publication de ce défi.
• C'est le code-golf , donc le code le plus court en octets gagne.
• Des échappatoires standard s'appliquent.

Prendre plaisir!

CJam, 51 45 42 38 36 octets

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

Ce qui précède utilise la notation caret; la séquence ^[est en fait le caractère ASCII avec le point de code 27.

J'ai emprunté la séquence d'échappement ( ^[c) à la réponse de @DomHastings ( avec sa permission ) pour économiser 4 octets.

Vérification

Vous pouvez recréer le fichier comme ceci:

base64 -d > jj.cjam <<< ImNcby8KXzBfIiIbY19vXwogMAovIFwbIntfb1w2ZTRtIX1n

Pour exécuter le code, téléchargez l' interpréteur CJam et exécutez ceci:

java -jar cjam-0.6.5.jar jj.cjam

Cela fonctionnera sur n'importe quel terminal qui prend en charge console_codes ou un sous-ensemble approprié. ¹

Comment ça marche

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.

¹ _{Les prises sautantes seront plus belles si vous masquez le curseur du terminal avant d'exécuter le programme. Dans Konsole, par exemple, vous pouvez définir la couleur du curseur pour qu'elle corresponde à la couleur d'arrière-plan. Cela doit être fait via les paramètres de votre terminal, car ^[créinitialise le terminal.}

Pyth - 41 40 39 octets

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

(Je compte les caractères \x1bcomme un octet car SO détruit les caractères spéciaux).

Clairement, ne fonctionne pas en ligne car c'est a) une boucle infinie et b) utilise des codes d'échappement terminaux.

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

J'ai été surpris de découvrir que l'augmentation-affectation fonctionnait avec la post-affectation. Pyth est génial.

QBasic, 58 octets

Testé sur QB64 .

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

La bonne langue pour le problème peut être étonnamment compétitive, même si elle est généralement verbeuse. Le ?raccourci pour PRINTaide aussi, bien sûr. CLSest cl oreille de l'creen; RUNsans arguments redémarre le programme, qui est le moyen le plus court pour obtenir une boucle infinie.

La seule autre astuce ici est l'impression 0pour la section médiane de la première photo. QBasic place un espace devant (et après) les valeurs numériques non négatives lors de leur impression, ce qui entraîne 0 . Plus de 3 caractères enregistrés " 0".

Je peux également souligner que le retard dans ce code est littéralement une seconde et ne dépend pas de la machine. ; ^ P

Perl (* nix) , 54 octets

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

( \x1best compté comme 1 octet mais échappé pour un test plus facile.) Ce qui précède a été testé avec Bash et raccourci d'un autre octet grâce à @Dennis !

Perl (Windows) , 56 octets

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

Merci à @Jarmex pour ses tests et ses conseils!

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

Assez simple. Utilise des chaînes de modèle pour stocker les images et bascule une valeur booléenne pour déterminer laquelle utiliser.

REMARQUE: cette solution peut ne pas être valide, car elle n'utilise pas réellement de console. Cependant, je ne pense pas qu'il soit possible d'effacer une console de navigateur en utilisant JS, du moins pas en utilisant Firefox.

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

<pre id=O>

Bash, 86 84 octets

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 octets

Fonctionne sur 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

Pour les machines UNIX, ajoutez deux octets:

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

Belle séance d'entraînement: D Je me demandais simplement si c'était faisable. Pas de prix à gagner cependant ...;)

Si quelqu'un veut tester cela: après avoir exécuté le programme, vous devez appuyer sur Ctrl + D (fin de saisie) pour démarrer réellement le bloc END. Pour y mettre fin, je dois utiliser Ctrl + Z.

J'ai également ceci, qui n'est que de 74 octets, mais cela commence par une pause d'une seconde, ce qui n'est pas le comportement souhaité, je pense

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

Lot - 82 octets

Modifier: la commande de temporisation a été désactivée et la nouvelle ligne supplémentaire a été supprimée.

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

J'ai vu 2 autres réponses de lot similaires, donc je ne voulais pas vraiment poster ceci, mais c'est mon tout premier golf.

BBC BASIC, 75 octets

Notez que la tokenisation le réduit à 75 octets. L'espace est ajouté par l'EDI.

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

JavaScript ES6, 100 95 octets

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

Se connecte à la console. Testé sur Safari Nightly

Lot, 151 130 118 octets

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 octets

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

Julia, 70 octets

(sous Windows , en remplaçant clearpar cls, grâce à undergroundmonorail)

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

Sous Linux, 72 octets

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

Cela utilise des sauts de ligne réels plutôt que \nd'enregistrer un octet; sinon, le iest soit 1 ou -1 comme "drapeau", et il utilise la récursivité pour réaliser la boucle infinie. Appelez-le soit n(1)ou juste n().

En outre, run(`clear`)/ run(`cls`)utilise une commande shell pour effacer la fenêtre, car Julia n'a pas de commande window-clear intégrée.

Windows Batch, 83 89

Edit a supprimé la ligne vide après la clarification par OP

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

Si vous vous débarrassez de la ligne vide chez l'homme qui saute (qui ne peut pas être vu de toute façon), le score est de 83

Remarque: timeoutn'est pas présent dans Windows XP. Il fonctionne dans Vista ou dans des versions plus récentes. De plus timeoutn'est pas précis à la seconde, c'est donc un choix parfait pour implémenter l'étape 4 (Attendez un moment ( environ une seconde ))

Javascript (ES6), 82 octets

Une modification de ma réponse précédente qui utilise la console. Fonctionne partiellement dans Firefox, mais efface uniquement la console dans Chrome, AFAIK.

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

Comme toujours, les suggestions sont les bienvenues!

JavaScript, 92 91 89 octets

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

• Aucune fonctionnalité ES6 (mais serait considérablement plus courte avec eux)
• Fonctionne avec Node.js sur Linux (je ne connais pas les autres environnements)
• Fonctionne partiellement dans la console de Chrome ( cs'affiche au lieu de vider la console, interrompre la sortie)

En supprimant "\033c"+le code ci-dessus, ce qui suit fonctionne dans le navigateur, mais n'efface pas la console.

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

Rubis, 79 octets

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

Nécessite des codes d'échappement.

Forth, 86 octets

Nécessite GNU Forth pour les chaînes échappées. Pour exécuter dans un Forth non GNU, changez simplement S\"en S"et les caractères échappés ne s'imprimeront pas correctement.

: 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 caractères)

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

Ce qui précède nécessite quelques explications, car le balisage Stack Exchange ne représente pas correctement les caractères PETSCII:

• Le programme est présenté ici pour plus de commodité en minuscules, mais peut et doit être entré et exécuté en mode majuscule sur un Commodore 64.
• Les premier et troisième caractères "S" sont en fait en vidéo inverse, et produits en appuyant sur la CLRtouche ( SHIFT+HOME ).
• Les caractères "q" sont en fait en vidéo inverse, et produits en appuyant sur le curseur bas ( CRSR ⇓).
• Le "|" les personnages sont en fait en vidéo inverse, et produits en appuyant sur le curseur gauche ( SHIFT+ CRSR ⇒).

cire d'abeille ,119 113 octets

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   <

Explication des parties importantes du programme:

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

Les fvaleurs poussent les valeurs sur la gstack (pile globale) pour une utilisation ultérieure. Ces valeurs sont accessibles par les instructions 0gh(ou en miroir hg0) et hg( gh). hfait pivoter la gstack vers le haut, glit la valeur maximale de gstack et la pousse sur la lstack (pile locale) de l'abeille (pointeur d'instruction).

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

Une explication détaillée suit plus tard, si nécessaire. Peut-être avec animation.

Poisson mort , sans compétition (658 octets)

iiisisdddddoiiiiiiiiiiiiiiiioddddddddddddddddodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddoddddsddddoiiiiiiiiiiiiiiiioddddddddddddddddoddddddddddddddddddddddodddsddodddddddddddddddoddddddddddddddddddddddsddddddddoddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddoosddddddddoiiiiiiiiiiiiiiiiiiioddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddodddddddddddddddddddddddddddddddddddddosdddddodddddddddddddddddddddddddddddddddddddddddddddddoddddddddddddddddddddddddddddddddddddddsdddddodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddoo

Il s'agit d'une solution non concurrente , car elle ne répond pas complètement aux exigences du défi. Deadfish est une langue interprétée très étrange, qui n'a que 4 commandes et un accumulateur. L'accumulateur est une variable à un octet initialisée à 0. Les 4 commandes sont:

• i = Incrémenter l'accumulateur a = a + 1
• d = Décrémenter l'accumulateur a = a - 1
• s = Mettre l'accumulateur au carré a = a * a
• o = Sortie de l'accumulateur print(a)

Comme la langue n'inclut pas la répétition, l'effacement de l'écran ou les retards, elle ne répond pas aux exigences. Production attendue:

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

Explication du code:

_  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

Interprète Deadfish dans 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 , non compressible 24 octets

Pas de compétition car Noodel est né après la création du challenge :)

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

Essayez-le :)

Comment ça marche

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

Il n'existe actuellement aucune version de Noodel qui prend en charge la syntaxe utilisée dans ce défi. Voici une version qui fait:

24 octets

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