De nombreux appareils électroniques, en particulier les plus anciens, clignotent 12:00lorsque l’heure n’a pas été réglée. Le but de ce défi est de recréer cela.

Plus précisément, la tâche consiste à afficher 12:00et --:--alternativement dans une boucle infinie .

La période doit être d'une seconde divisée en deux périodes égales de 0,5 seconde. Ici, "1 seconde" et "uniformément" peuvent être interprétés librement. Par exemple, il est acceptable que le code marque une pause de 0,5 seconde entre l'affichage des chaînes, même si la période résultante sera alors légèrement supérieure à 1 seconde. Une pause initiale avant d'afficher la première chaîne est acceptable.

Chaque nouvelle chaîne peut être affichée en remplaçant la chaîne précédente ou dans une nouvelle ligne . Les espaces de fin sont autorisés, sauf que si chaque nouvelle chaîne est sur une ligne différente, il ne doit pas y avoir de lignes vides entre des chaînes consécutives.

Le code le plus court en octets gagne.

Gelée , 20 octets

.“12:00“--:--”ṄœS¥€ß

Comment ça marche

.“12:00“--:--”ṄœS¥€ß  Main link. No arguments.

.                     Set the return value to 0.5.
 “12:00“--:--”        Yield ["12:00", "--:--"].
                 ¥    Combine the two links to the left into a dyadic chain.
              Ṅ       Print the left argument.
               œS     Sleep as many seconds as the right argument specifies.
                  €   Map the created dyadic chain over the string array, with
                      right argument equal to the return value, i.e., 0.5.
                   ß  Recursive call the main link.

HTML / CSS, 131 108 106 101 + 18 17 = 149 126 125 123 118 octets

a{background:#FFF;margin:-5ch;animation:a 1s steps(2,start)infinite}@keyframes a{to{visibility:hidden

<tt>--:--<a>12:00

Edit: 23 octets enregistrés grâce à @insertusernamehere. Enregistré 1 octet en passant de <pre>à <tt>. 2 octets sauvés grâce à @darrylyeo. 5 octets sauvegardés grâce à @DBS.

Shell et pv26 octets

Cet yesoutil standard et l’ pv élément de pipeline Shell permettent de mesurer les données transitant par

yes '12:00
--:--'|pv -qlL2

Python2, 80 75 73 69 67 66 octets

import time
n=0
while[time.sleep(.5)]:print"1-2-::0-0-"[n::2];n^=1

J'ai remarqué que ma magie de chaîne était un peu plus longue que de la sélectionner dans un tableau. Nevermind, compris.

Explication :

• Je mets un compteur n à 0, qui sera basculé entre 0 et 1.

• Je boucle sans fin avec la boucle while 1.

• Je crée une chaîne 1-2-::0-0-, qui contient la chaîne 12:00et --:--entrelacé.

  • En partant de l'index 0 avec un pas de 2, on obtient: 12:00

  • En partant de l'index 1 avec un pas de 2, on obtient: --:--

• J'utilise n pour faire la séquence répétée 0 , 1 , 0 , 1 , 0 ... qui sera l'index de départ de la chaîne.

  • En utilisant n^=1, dans chaque boucle, nous obtenons cette séquence. ^être l'opérateur XOR.
  • Si n == 0 -> n^=1résulte en 1
  • Si n == 1 -> n^=1résulte en 0
• J'imprime la chaîne et je dors ( .5-> 0.5) secondes.

@ FlipTack a enregistré 4 octets! -> Mettez la boucle dans une ligne.

@Rod enregistré 2 octets! -> n+=1to n^=1, donc n%2to n.

@xnor a sauvegardé un octet! -> while 1-> while[time.sleep(.5)].

Octave, 63 62 61 55 octets

c='--:--00:21';while c=flip(c)disp(c(1:5));pause(.5)end

Sauvegardé deux octets grâce à Tom Carpenter! L'utilisation d'une seule chaîne au lieu de deux dans un tableau de cellules était plus courte.

Explication:

c='--:--00:21';  % A string where the 5 first characters are --:-- or 12:00 when reversed
while c=flip(c)  % A string is always considered true in Octave, so this will loop forever
                 % while flipping the order of the string each time
 disp(c(1:5)     % display the 5 first characters of the string c
 pause(.5)       % Pause 0.5 second
end              % End loop

Quelques octets enregistrés car Octave ne nécessite pas de deux points ou de points-virgules entre flip(c)et disp(), et entre pause(.5)et end.

JavaScript, 59 octets

y=1;setInterval('console.log(["12:00","--:--"][y^=1])',500)

Explication

setInterval('...',500) définit un intervalle pour exécuter le code dans la chaîne toutes les 500 millisecondes, ou 1/2 par seconde.

y=1définit une variable y, à 1 initialement. De cette façon, la première chose imprimée est 12:00parce qu’elle yest utilisée pour accéder au tableau.

console.log(...)connecte quoi que ce soit à la console, que ce soit 12:00ou --:--.

["12:00","--:--"][y^=1]crée un tableau avec des chaînes contenant les deux états. Ensuite, yest utilisé pour accéder à l'un des éléments. Enfin, ^=ou l'opérateur composé XOR le fait y = y ^ 1. Cela inverse simplement le bit car 1 ^ 1vaut 0 et 0 ^ 1vaut 1, comme ce que @TuukkaX a fait . De cette façon, la chaîne journalisée alterne entre les deux éléments du tableau et crée ainsi l'effet clignotant.

V , 31 30 27 25 24 octets

Enregistré 5 octets grâce à @ nmjcman101 en échangeant l'ordre 12:00et de --:--sorte que kpeut être retiré tout en retirant òafin qu'il puisse être ajouté implicitement à la fin

Enregistrée 1 octet grâce à @DJMcMayhem en mettant à la fois 12:00et --:--dans une ligne

i12:00--:--<ESC>bDòVp:sl500m

Ancienne solution:

i12:00<ESC>ò:sl500m
Óä/-
:sl500m
uò

<ESC> est 0x1b

Hexdump:

00000000: 6931 323a 3030 2d2d 3a2d 2d1b 6244 f256  i12:00--:--.bD.V
00000010: 703a 736c 3530 306d                      p:sl500m

Explication

i12:00--:--<ESC>   inserts 12:00\n--:--
bD                 go to the beginning of --:-- and delete it
ò                  recursively do:
 Vp                 select line and paste (effectively doing a replace)
 :sl500m            sleep for 500 milliseconds
                   the last ò is added implicitly at the end

Gif (obsolète)

Remarque: j'ai mis en évidence activé

bash, 58 56 45 octets

sauvé 3 octets en supprimant --après setcomme 1er argument est un nombre.

set 12:00 --:--;for((a=1;;a=3-a)){ echo ${!a};sleep .5;}

16 octets enregistrés en utilisant la syntaxe de @DigitalTrauma :

f()(echo $1;sleep .5);f 12:00;f --:--;exec $0

Puis perdre 5 octets à cause du commentaire de zeppelin .

Cela n'a pas pu être testé en ligne de commande. Lorsque nous impliquons $0, cela doit être écrit dans un script pour pouvoir être exécuté.

Détourner

Avec un peu de préparation, cela pourrait devenir intéressant ( 412 octets ):

set -- "         ▗▖         
▗▄▄▖▗▄▄▖ ▝▘ ▗▄▄▖▗▄▄▖
         ▗▖         
         ▝▘         " " ▟▌ ▟▀▜▖ ▗▖ ▗▛▙ ▗▛▙ 
 ▐▌  ▗▟▘ ▝▘ █▗▐▌█▗▐▌
 ▐▌ ▗▛▗▖ ▗▖ ▜▖▟▘▜▖▟▘
▝▀▀▘▀▀▀▘ ▝▘  ▀▘  ▀▘ "
r=`tput cup 0`
clear;for((a=1;;a=3-a)){ printf "$r${!a}";sleep .5;}

Ou même deux mêmes lignes mais avec:

set -- '                                            






      HM!          .o#HMMMMM#o.                 .o#MMMMH#\\         .d#MMMMH#\\
    _HMMi         ?MMH*"""`"MMMb               dMMH"""`*MMH,      dMMH"""`*MMH.
##HMMMMMi        |MMP"       9MML             ?MMP      `MMM.    dMM?      `MMM.
`""`"9MM|        dMM!        -MMR     HMH}   .MMM        |MM}   .MMH        |MM|
     |MM|         "`         JMMT     dHH}   |MM|         MMM   |MM|        -MMM
     |MM!                 .,HMM*             |MM|         MMM.  ]MM|         MMM
     |MMi              _o#MMH*"              |MM|         MMM   {MM|         MMM
     |MMi           .dHMM#""                 |MM|         MMM"  {MM|        .MMM
     |MMi         .HMM*"                     `MM6        ,MMR   |MM}        |MMF
     |MMi        ,MMP"                        9MM,       dMM|    HMM,       dMM"
     {MMi        MMM?\\o,\\\\\\\\\\\\\\\\,     q##+    `HMM\\    .dMM?     `HMH\\    .dMM?
     |MM|       :MMMMMMMMMMMMMMM[     HMMk     `*HMM##MMM#"       `*HMM##MMMP"
      "`          "     ` ` ` `                   """"`""            """"""    ' '









                                      MHM|                                      
                                      HHH|                                      

               ______.  ._______.            ________.  ._______.               
               MMMMMM:  {MMMMMMM|            &MMMMMMM:  |MMMMMMM[               


                                      ###|                                      
                                      MMM|                                      
                                                                               '

Perl, 49 octets

{select$,,$,,$,,0.5;say$|--?"12:00":"--:--";redo}

Perl ne sleeppeut pas dormir pendant une durée inférieure à 1 seconde, d'où l'utilisation de select undef, undef, undef, .5(jouée en remplaçant undefpar $,) pour dormir 0,5 seconde.
Autre chose intéressante: $|ne peut que tenir 0ou 1. Donc, $|--change simplement sa valeur, de 0à 1.
Et finalement, {... ;redo}agit comme une boucle infinie.

*> <> , 43 42 octets

<v":1200----"
S>@5dov>~r@@}r5
1&}o:&<^!?:-

Essayez-le ici!

Je sens que je devrais être capable de raccourcir ça, j'ai quelques idées à essayer ... En gros, ça fait une pile de :1200----. Il isole le :et retourne la pile en l'insérant :au milieu de l'un ----ou de l'autre 1200(en fonction de la fin de la pile).

Je dois également noter que la seule instruction *> <> utilisée est S(veille), sinon il s'agit d'un programme approprié> <>.

Mise à jour: 1 octet enregistré en déplaçant le :vers la droite au lieu de le protéger avec un registre.

Explication

Initialisation

<v":1200----"

Ici, nous construisons la pile que nous utiliserons pour la vie du programme.

<              move the IP left
  ":1200----"  push ":1200----" to the stack
 v             move the IP down into "output time"

Temps de sortie

 >@5dov
1&}o:&<^!?:-

C'est la section où le temps est réellement sorti. Le premier 5 est poussé vers la pile afin que la boucle ci-dessous sache s'exécuter 5 fois.

Initialisation:

 >@5dov

 >       move the IP right
  @      move the ":" back two spaces in the stack
   5     push 5 to the stack (let's call this `i`)
    do   output carriage return
      v  move IP down into "loop"

Loop:

1&}o:&<^!?:-

      <       move the IP left
     &        place i onto the register
  }o:         output a character and shift the stack left
 &            place i back onto the stack
1          -  decrement i by 1
       ^!?:   if i == 0, exit to "recover and swap"

Récupérer et échanger

S      >~r@@}r5

Ici, nous récupérons la :position qui en résulte après la sortie, et nous nous retrouvons avec une pile inversée. En fait, cela se termine bien dans "temps de sortie", provoquant une boucle infinie.

       >         move the IP right
        ~        remove trailing i from stack
         r@@     reverse the stack and move ":" to the front
            }r   reverse the stack again, keeping ":" on the front
S             5  sleep for 500ms

Solution de 45 octets

<v[5"12:00"1
d/S5
o/!?l
v>]?v
 00.>0"--:--"5[

Essayez-le ici!

Celui-ci est aussi fondamentalement un programme <>.

J'ai vraiment pensé qu'il serait possible d'économiser des octets avec cette approche. Ceci sort tout simplement 12:00, alors --:--. Je sauve des octets en réutilisant la routine de sortie o/!?l(je réutilise même ce miroir comme entrée et comme sortie). J'utilise plusieurs piles pour stocker l'état (avec sortie 12ou --) et sélectionne l'état avec lequel je devrais sortir v>]?v.

^{Explications à venir bientôt! (1/2)}

HTML / CSS (Chrome uniquement), 80 + 4 = 84 octets

tt:after{content:"--:--";animation:a 1s infinite}@keyframes a{to{content:"12:00"

<tt>

Modifier : l'attribut "contenu" ne peut pas être animé par la spécification CSS , mais se trouve sur le navigateur Web de bureau Chrome.

Noodel , non concurrent de 16 octets

--:-- 12:00ḷçėḍh

Noodel est toujours un travail en cours. J'essaie juste de me mouiller avec quelques défis.

Essayez-le :)

Comment ça marche

--:--            # Creates the string literal "--:--" and places i into the front of the pipe.
                 # Space is a NOP command to separate the string literals.
      12:00      # Creates the string literal "12:00" and places it into the front of the pipe.
           ḷ     # Loop the following code unconditionally.
            ç    # Clear the screen and print a copy of what is in the pipe.
             ė   # Take what is in the front of the pipe and put it into the back.
              ḍh # Delay for half a second.

Voici un extrait de code :)

<div id="noodel" code="--:-- 12:00ḷçėḍh" input="" cols="10" rows="2"></div>

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

QBIC , 37 33 octets

{sleep 01?@12:00`┘sleep 01?@--:--

QBasic ne peut malheureusement dormir que pendant des secondes entières. Je réfléchirai à la mise au point d'une méthode permettant plus de flexibilité bientôt. J'ai entré 1 comme 01pour simuler .5.

Explication:

{         Starts DO loop
sleep 01  Sleeps for 1 second
?@12:00`  Creates A$, sets value to "12:00" and prints A$
┘         Newline: a string literal doesn't break the line, so we need a newline to 
          control the compiled QBasic syntax
          <Rinse and repeat for "--:--">
          <DO-LOOP implicitly closed by QBIC>

Dans les versions plus anciennes de QBIC, $et (espace) étaient des caractères réservés. L'appel d'une fonction QBasic qui nécessitait des espaces (comme sleep x) ou $( left$(..)) nécessitait un littéral de code:

'QBASIC CODE`

Le code dans un bloc littéral de code est passé directement à QBasic sans être analysé par QBIC. En déchargeant des fonctions de ces symboles ( $devenus ', et les nouvelles lignes sont maintenant ┘(alt-217) au lieu de ), les symboles ne sont plus considérés par QBIC comme des caractères spéciaux, mais simplement transmis. La même chose est effectivement vraie pour l'alphabet minuscule: il est utilisé pour représenter les variables numériques à la fois dans QBIC et QBasic et reste inchangé. Utiliser une fonctionnalité QBasic qui n'est pas implémentée dans QBIC (comme SLEEP) consiste simplement à ne pas utiliser les caractères réservés à QBIC. Ceci est facilité par les modifications récentes des symboles de commande.

JavaScript, 77 76 72 octets

setInterval('l=console.log,l("12:00"),setTimeout("l(`--:--`)",‌​500)',1e3)

Merci à Kritixi Lithos pour 1 octet et L. Serne pour 4 octets!

Python 2, 88 85 73 71 octets

import time
c="--:--00:21"
while 1:print c[:5];c=c[::-1];time.sleep(.5)

Essayez-le ici!

En empruntant l’idée de Stewie Griffin de retourner la liste, le programme est devenu possible. Version non-lisée avec explication:

import time                      # Import time module
c = "--:--00:21"                 # String with two values
while 1:                         # Infinite Loop
    print c[::5]                 # Print the first 5 chars in string
    c = c[::-1]                  # Flip the string
    time.sleep(.5)               # Wait 0.5 seconds

Merci @ FlipTack pour la sauvegarde de 14 octets!

PHP, 51 50 47

for(;;usleep(5e5))echo$i++%2?"--:--
":"12:00
";

1 octet enregistré en raison de manatwork et 3 autres enregistrés par insertusernamehere. Merci!

Pyth, 23 octets

#?=!Z"12:00""--:--".d.5

En pseudocode:

                Z = 0
#               while 1:
 ?=!Z               if ( Z = not Z ):
     "12:00"            print("12:00")
                    else:
     "--:--"            print("--:--")
 .d.5               sleep(0.5)

Utilise la variable pré-initialisée Zcomme bascule et inverse son état à chaque fois ifpour vérifier l'état.

ruby, 47 42 octets

Pas encore de réponse, alors voici mon premier essai:

%w{12:00 --:--}.cycle{|a|puts a;sleep 0.5}

GNU sed, 39 octets

EDITS:

• Sommeil échangé et i12: 00 (pour rendre le code source plus esthétique)

Golfé

s/^/sleep .5/
h
i12:00
e
i--:--
x
e
G
D

A expliqué

s/^/sleep .5/   #Put 'sleep .5' to the pattern space
h               #Copy pattern space to hold space
i12:00          #Print "12:00" (insert before a line) 
e               #Execute command that is found in pattern space
i--:--          #Print "--:--"
x               #Exchange the contents of the hold and pattern spaces
e               #Execute command that is found in pattern space

G               #Append a newline to the contents of the pattern 
                #space, and then append the contents of the hold
                #space to that of the pattern space.

D               #Delete text in the pattern space up to the 
                #first newline, and restart cycle with the 
                #resultant pattern space, without reading a new 
                #line of input.

Essayez-le en ligne!

dc (bash), 37 octets

[12:00][--:--][[rp!sleep .5]xlax]dsax

Cela fonctionne en poussant les deux chaînes "12:00" et "-: -" sur la pile, puis en échangeant plusieurs fois les valeurs, en imprimant l'élément en haut de la pile et en dormant une demi-seconde.

Pour l'exécuter, vous pouvez l'enregistrer dans un fichier, puis taper

nom de fichier dc

ou vous pouvez l'exécuter directement à partir de la ligne de commande bash en tapant

dc <<< '[12:00] [-: -] [[rp! sleep .5] xlax] dsax'

Perl 6 ,  48 41  34 octets

loop {print "\r",<--:-- 12:00>[$_=!$_];sleep .5}

loop {put <--:-- 12:00>[$_=!$_];sleep .5}

sleep .put/2 for |<12:00 --:-->xx*

Gelée, 22 octets

®‘©ị“12:00“--:--”ṄœS.ß

Ne fonctionne pas sur TIO. Faire fonctionner Jelly sur Android avec QPython3 était également une expérience amusante.

Explication

®‘©ị“12:00“--:--”ṄœS.ß    Main link. No arguments. 
®                         Read the register. Initially 0.
 ‘                        Increment. 
  ©                       Save to the register.
   ị                      Get the n'th (wrapping) item of...
    “12:00“--:--”         ["12:00", "--:--"]
                 Ṅ        Print the string and a newline. 
                  œS      Sleep for...
                    .     ...0.5 seconds. (. is an alias for 0.5)
                     ß    Call this link again. 

Mathematica, 38 octets

Dynamic@If[Clock[]>.5,"12:00","--:--"]

Explication

Clock[]

Émet une variable d’horloge qui passe continuellement de 0 à 1 toutes les secondes.

If[Clock[]>.5,"12:00","--:--"]

Si la variable d'horloge est supérieure à 0,5, indiquez "12:00". Sinon, éditer "-: -".

Dynamic@ ...

Rendre le programme dynamique (mise à jour constante)

Javascript, 57 55

setInterval('console.log(++i%2?"12:00":"--:--")',i=500)

2 octets économisés grâce aux ETHproductions

Postscript 225 214

Pour le plaisir seulement! N'envoyez pas ceci à une vraie imprimante !!

/Courier findfont 9 scalefont setfont{usertime 500 mod 5 lt{newpath 9 9 moveto 1 setgray 99 setlinewidth 99 99 lineto stroke 0 setgray}if newpath 9 9 moveto usertime 999 mod 500 lt{(--:--)}{(12:00)}ifelse show}loop

Essayez le:

gs -c '/Courier findfont 9 scalefont setfont{usertime 500 mod 5 lt{newpath 9 9 moveto 1 setgray 99 setlinewidth 99 99 lineto stroke 0 setgray}if newpath 9 9 moveto usertime 999 mod 500 lt{(--:--)}{(12:00)}ifelse show}loop'

ou

cat <<eops >/tmp/blinkingTwelve.ps
%!
/Courier findfont
9 scalefont
setfont
{
  usertime 500 mod 5 lt {
    newpath
    9 9 moveto
    1 setgray
    99 setlinewidth
    99 99 lineto
    stroke
    0 setgray
  } if
  newpath
  9 9 moveto
  usertime 999 mod 500 lt {
    (--:--)
  } {
    (12:00)
  } ifelse
  show
} loop
eops

puis

gs /tmp/blinkingTwelve.ps
gv /tmp/blinkingTwelve.ps

Mais n'essayez pas de l'ouvrir avec une visionneuse plus sophistiquée et de vous intéresser à la vignette du bureau!

Javascript (navigateur), 174 160 159 122 112 111 109 107 66 (91) octets

J'ai choisi de ne pas preutiliser de police monotypée . Mon nouveau compte est donc 66 . Certains caractères sont ajoutés pour utiliser des polices à espacement fixe, mais comme cela n'est pas nécessaire, je ne compterai pas ces 25 caractères supplémentaires.

Merci à ETHproductions pour avoir économisé 14 octets,

à Kritixi Lithos pour enregistrer 1 octet,

pour manipuler pour sauver 1 3 octets,

à Christoph pour avoir sauvé deux autres octets et

me faire économiser 37 octets en utilisant [..][b^=1]au lieu de setTimeout... et 10 autres en les remplaçant function(){..}par des guillemets ...

setInterval("document.body.innerHTML=++b%2?'12:00':'--:--'",b=500)

body{font-family:Courier}

... pire:

De 66 à quelque chose de plus ...

... mais pour le plaisir, dans l'esprit d'un affichage clignotant:

SVG="http://www.w3.org/2000/svg";XLNK="http://www.w3.org/1999/xlink";
s=["1200","----"];p=0;function d(n){for(i=n.length;i>0;i--) {
  document.getElementById('n'+i).setAttribute('class','n'+n[i-1])}
  document.getElementById('sz').setAttribute('class','n'+n[0])}
setInterval("p=1-p;d(s[p])",500);

#svg2 { --c: #FF6;stroke:#432;stroke-width:12;stroke-linecap:round;stroke-linejoin:round; stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:none; } path.b { fill:#543;stroke:none; } .blue     { --c: #68F; } .green    { --c: #6F8; } .red      { --c: #F88; } .dec rect  { stroke: var(--c); } .n1 #B { stroke: var(--c); }  .n1 #C { stroke: var(--c); } .n2 #A { stroke: var(--c); }  .n2 #B { stroke: var(--c); } .n2 #D { stroke: var(--c); }  .n2 #E { stroke: var(--c); } .n2 #G { stroke: var(--c); }  .n3 #A { stroke: var(--c); } .n3 #B { stroke: var(--c); }  .n3 #C { stroke: var(--c); } .n3 #D { stroke: var(--c); }  .n3 #G { stroke: var(--c); } .n4 #B { stroke: var(--c); }  .n4 #C { stroke: var(--c); } .n4 #F { stroke: var(--c); }  .n4 #G { stroke: var(--c); } .n5 #A { stroke: var(--c); }  .n5 #C { stroke: var(--c); } .n5 #D { stroke: var(--c); }  .n5 #F { stroke: var(--c); } .n5 #G { stroke: var(--c); } .n6 #A { stroke: var(--c); }  .n6 #C { stroke: var(--c); } .n6 #D { stroke: var(--c); }  .n6 #E { stroke: var(--c); } .n6 #F { stroke: var(--c); }  .n6 #G { stroke: var(--c); } .n7 #A { stroke: var(--c); }  .n7 #B { stroke: var(--c); } .n7 #C { stroke: var(--c); } .n8 #A { stroke: var(--c); }  .n8 #B { stroke: var(--c); } .n8 #C { stroke: var(--c); }  .n8 #D { stroke: var(--c); } .n8 #E { stroke: var(--c); }  .n8 #F { stroke: var(--c); } .n8 #G { stroke: var(--c); } .n9 #A { stroke: var(--c); }  .n9 #B { stroke: var(--c); } .n9 #C { stroke: var(--c); }  .n9 #D { stroke: var(--c); } .n9 #F { stroke: var(--c); }  .n9 #G { stroke: var(--c); } .n0 #A { stroke: var(--c); }  .n0 #B { stroke: var(--c); } .n0 #C { stroke: var(--c); }  .n0 #D { stroke: var(--c); } .n0 #E { stroke: var(--c); }  .n0 #F { stroke: var(--c); } .n11 #B { stroke: var(--c); } .n11 #C { stroke: var(--c); } .n11 #E { stroke: var(--c); } .n11 #F { stroke: var(--c); } .nA #A { stroke: var(--c); }  .nA #B { stroke: var(--c); } .nA #C { stroke: var(--c); }  .nA #E { stroke: var(--c); } .nA #F { stroke: var(--c); }  .nA #G { stroke: var(--c); } .nB #C { stroke: var(--c); }  .nB #D { stroke: var(--c); } .nB #E { stroke: var(--c); }  .nB #F { stroke: var(--c); } .nB #G { stroke: var(--c); } .nC #A { stroke: var(--c); }  .nC #D { stroke: var(--c); } .nC #E { stroke: var(--c); }  .nC #F { stroke: var(--c); } .nD #B { stroke: var(--c); }  .nD #C { stroke: var(--c); } .nD #D { stroke: var(--c); }  .nD #E { stroke: var(--c); } .nD #G { stroke: var(--c); } .nE #A { stroke: var(--c); }  .nE #D { stroke: var(--c); } .nE #E { stroke: var(--c); }  .nE #F { stroke: var(--c); } .nE #G { stroke: var(--c); } .nF #A { stroke: var(--c); }  .nF #E { stroke: var(--c); } .nF #F { stroke: var(--c); }  .nF #G { stroke: var(--c); } .nR #E { stroke: var(--c); }  .nR #G { stroke: var(--c); } .nO #C { stroke: var(--c); }  .nO #D { stroke: var(--c); } .nO #E { stroke: var(--c); }  .nO #G { stroke: var(--c); } .n- #G { stroke: var(--c); }  .n1 #y { stroke: var(--c); } .n1 #z { stroke: var(--c); }

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="100%" height="100%" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 645 230" id="svg2"> <defs id="dfs4"><g id="n"><path d="M 15,5 155,5 145,225 5,225 z" class="b"/> <path id="A" d="M 45,15 125, 15"/><path id="B" d="M 135,25 125,105"/><path id="C" d="M 125,125 115,205"/><path id="D" d="M 25,215 105,215"/><path id="E" d="M 25,125 15,205"/><path id="F" d="M 35,25 25,105"/><path id="G" d="M 35,115 115,115"/><rect id="P" width="5" height="5" ry="2.5" x="130" y="205"/></g><g id="s"><path d="M 10,5 35,5 25,225 0,225 z" id="a" class="b"/><rect id="y" width="5" height="5" ry="2.5" x="13.5" y="145"/><rect id="z" width="5" x="17" height="5" ry="2.5" y="75"/></g></defs><use id="n1" xlink:href="#n" /><use id="n2" xlink:href="#n" transform="translate(150,0)" /><use xlink:href="#s" id="sz" transform="translate(305,0)"/><use id="n3" transform="translate(335,0)" xlink:href="#n" /><use id="n4" xlink:href="#n" transform="translate(485,0)" />
</svg>

QuickBASIC , 167 piqûres (délicieux)

a%=VAL(RIGHT$(STR$(TIMER*100),2))
b%=a%+50
IF b%>99THEN b%=b%-99
DO
c%=VAL(RIGHT$(STR$(TIMER*100),2))
IF c%=a% THEN PRINT"--:--"
IF c%=b% THEN PRINT"12:00"
LOOP

Je n'allais jamais gagner de toute façon. QB n'a pas de floor (), et n'a pas non plus de fonction pour dormir pendant x millisecondes. Par conséquent, cela fonctionne en saisissant la partie à virgule flottante de la minuterie (le nombre de secondes écoulées depuis minuit, plus une fraction de la seconde en cours exprimée en décimale à deux chiffres). Nous y ajoutons ensuite une boucle "50 unités" pour déterminer le moment où la phase doit basculer de "-: -" à "12:00", et nous utilisons la décimale TIMER d'origine pour le basculement de "12:00". à "--:--".

Enfin, même si cela est conforme à QB4.5, DOSBox sur une machine assez puissante ignorera les temps. En effet, QB n’est vraiment pas assez rapide pour effectuer la DO-LOOP et les évaluations à l’intérieur du MS dans lequel nous effectuons la comparaison. Aurait besoin d’une boîte de la FUTURE!

Quoi qu'il en soit, j'ai maintenant l'air d'avoir 100 ans et j'ai rendu heureux tous les étudiants de l'université américaine, car ils ont probablement une réponse à donner à leur cours de Comp Sci - puisqu'ils enseignent encore cette ...

Clojure, 79 62 octets

V2

-17 octets en passant d'une terrible boucle d'indexation à une liste infinie.

Crée une liste infinie de "12:00"et "--:--"répéter encore et encore, puis utilise doseqpour tirer constamment le message suivant, et l' imprimer.

(doseq[m(cycle["12:00""--:--"])](Thread/sleep 500)(println m))

V1

(loop[i 0](Thread/sleep 500)(println(["12:00""--:--"]i))(recur(if(= 0 i)1 0))))

Je ne pouvais pas penser à un bon moyen de compacter les constantes "12:00" et "-: -", donc je devais les coder en dur.

Ungolfed:

(loop [i 0] ; Track which sign we showed last
    (Thread/sleep 500)
    (println (["12:00" "--:--"] i)) ; Index the vector to get the string to print
    (recur (if (= 0 i)1 0))) ; Swap the index, and loop again

Pushy , 22 octets (non concurrents)

`--:`wO`12:0`&["500oWF

Cette réponse utilise les deux piles, en les retournant, en imprimant les caractères à tour de rôle:

`--:`    \ Push these characters to stack 1
 w       \ Mirror around center, yielding "--:--"
 O       \ On the second stack...
 `12:0`  \ Push these characters
 &       \ Duplicate the last (for :00)

 [        \ Infinitely:
  "       \   Print the current stack
  500oW   \   Wait 500 milliseconds
  F       \   Swap stacks
          \ (Implicit end loop)

La oWcommande fait partie d'un ensemble de commandes expérimentales postérieures au défi, rendant cette réponse non concurrente.

Windows PowerShell, 46 55 octets

function a{sleep -m 500;cls};for(){"12:00";a;"--:--";a}

Code d'origine:

a{sleep -m 500;cls};for(){"12:00";a;"--:--";a}
^ this won't work on other PCs. No idea why.