Molti dispositivi elettronici, specialmente quelli vecchi, mostreranno un lampeggio 12:00quando non è stato impostato l'orario. Lo scopo di questa sfida è ricrearlo.

In particolare, l'attività è di visualizzare 12:00e in --:--alternativa in un ciclo infinito .

Il periodo dovrebbe essere di 1 secondo, diviso equamente in due periodi di 0,5 secondi. Qui "1 secondo" e "uniformemente" possono essere interpretati liberamente. Ad esempio, è accettabile se il codice si interrompe per 0,5 secondi tra la visualizzazione delle stringhe, anche se il periodo risultante sarà quindi leggermente superiore a 1 secondo. È accettabile una pausa iniziale prima di visualizzare la prima stringa.

Ogni nuova stringa può essere visualizzata sostituendo la stringa precedente o in una nuova riga . È consentito lo spazio bianco finale, tranne per il fatto che se ogni nuova stringa si trova su una riga diversa, non dovrebbero esserci righe vuote tra le stringhe consecutive.

Vince il codice più breve in byte.

Gelatina , 20 byte

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

Come funziona

.“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 byte

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

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

Modifica: salvato 23 byte grazie a @inserireusernamehere. Salvato 1 byte passando da <pre>a <tt>. Salvato 2 byte grazie a @darrylyeo. 5 byte salvati grazie a @DBS.

Shell e pv, 26 byte

Questo utilizza lo yesstrumento standard e l' pv elemento pipeline Shell per misurare il passaggio dei dati

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

Python2, 80 75 73 69 67 66 byte

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

Ho notato che la mia magia delle corde è diventata un po 'più lunga rispetto alla raccolta della corda da un array. Non importa, l'ho capito.

Spiegazione :

• Ho impostato un contatore n su 0, che verrà commutato tra 0 e 1.

• Ciclo all'infinito con il ciclo while 1.

• Creo una stringa 1-2-::0-0-, che contiene la stringa 12:00e --:--interlapped.

  • A partire dall'indice 0 con un passaggio di 2, otteniamo: 12:00

  • A partire dall'indice 1 con un passaggio di 2, otteniamo: --:--

• Uso n per creare la sequenza ripetuta 0 , 1 , 0 , 1 , 0 ... che sarà l'indice iniziale della stringa.

  • Usando n^=1, in ogni ciclo, otteniamo quella sequenza. ^essendo l'operatore XOR.
  • Se n == 0 -> n^=1risulta 1
  • Se n == 1 -> n^=1risulta 0
• Stampo la stringa e dormo ( .5-> 0.5) secondi.

@FlipTack ha salvato 4 byte! -> Metti il ​​loop in una riga.

@Rod ha salvato 2 byte! -> n+=1a n^=1, quindi n%2a n.

@xnor ha salvato un byte! -> while 1-> while[time.sleep(.5)].

Ottava, 63 62 61 55 byte

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

Risparmiato due byte grazie a Tom Carpenter! L'uso di una singola stringa anziché di due stringhe in un array di celle era più breve.

Spiegazione:

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

Alcuni byte salvati perché Octave non richiede due punti o punto e virgola tra flip(c)e disp(), e tra pause(.5)e end.

JavaScript, 59 byte

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

Spiegazione

setInterval('...',500) imposta un intervallo per eseguire il codice nella stringa ogni 500 millisecondi o 1/2 al secondo.

y=1imposta yinizialmente una variabile , su 1. In questo modo, la prima cosa che viene stampata è 12:00perché yviene utilizzata per accedere all'array.

console.log(...)registra qualsiasi cosa sulla console, in questo 12:00o --:--.

["12:00","--:--"][y^=1]crea una matrice con stringhe contenenti entrambi gli stati. Quindi, yviene utilizzato per accedere a uno degli elementi. Infine, ^=o l'operatore composto XOR lo fa y = y ^ 1. Questo inverte il bit perché 1 ^ 1è 0, ed 0 ^ 1è 1, simile a quello che ha fatto @TuukkaX . In questo modo, la stringa registrata si alterna tra i due elementi dell'array e crea così l'effetto lampeggiante.

V , 31 30 27 25 24 byte

Salvato 5 byte grazie a @nmjcman101 scambiando l'ordine di 12:00e in --:--modo che kpossa essere rimosso qualsiasi rimuovendolo in òmodo che possa essere aggiunto implicitamente alla fine

Salvato 1 byte grazie a @DJMcMayhem inserendo entrambi 12:00e --:--in una riga

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

Vecchia soluzione:

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

<ESC> è 0x1b

hexdump:

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

Spiegazione

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 (obsoleto)

Nota: ho evidenziato l'evidenziazione

bash, 58 56 45 byte

salvato 3 byte sopprimendo --dopo setcome 1st arg è un numero.

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

16 byte salvati utilizzando la sintassi di @DigitalTrauma :

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

Quindi perdere 5 byte a causa del commento di Zeppelin .

Questo non può essere testato dalla riga di comando. Per quanto ci riguarda $0, questo deve essere scritto in uno script per essere eseguito.

Deviazione

Con un po 'di preparazione, questo potrebbe diventare piacevole ( 412 byte ):

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

O anche le stesse due righe ma con:

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 byte

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

Il Perl sleepnon riesce a dormire per 1 secondo, quindi l'uso di select undef, undef, undef, .5(golfizzato sostituendolo undefcon $,) per dormire 0,5 secondi.
Altra cosa interessante: $|può contenere solo 0o 1. Quindi $|--commuta il suo valore, da 0a 1.
E infine, si {... ;redo}comporta come un ciclo infinito.

*> <> , 43 42 byte

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

Provalo qui!

Sento che dovrei essere in grado di accorciarlo, ho un paio di idee da provare ... Fondamentalmente questo fa una pila di :1200----. Isola il :e capovolge la pila, inserendo la :al centro di una ----o 1200(a seconda di quale si trova alla fine della pila).

Dovrei anche notare che l'unica * * <> istruzione che utilizza è S(sleep), altrimenti si tratta di un programma> <> appropriato.

Aggiornamento: 1 byte salvato spostando :a destra invece di proteggerlo con un registro.

Spiegazione

Inizializzazione

<v":1200----"

Qui costruiamo lo stack che useremo per la durata del programma.

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

Tempo di uscita

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

Questa è la sezione in cui viene effettivamente emesso il tempo. I primi 5 vengono inseriti nello stack in modo che il ciclo sottostante sappia che viene eseguito 5 volte.

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"

Ripristina e scambia

S      >~r@@}r5

Qui recuperiamo :dalla posizione in cui risulta dopo l'output e finiamo con uno stack inverso. Questo in realtà termina correttamente nel "tempo di uscita", causando un ciclo infinito.

       >         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

Soluzione a 45 byte

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

Provalo qui!

Anche questo è fondamentalmente un programma> <>.

Ho davvero pensato che sarebbe stato in grado di salvare alcuni byte con questo approccio. Questo semplicemente produce 12:00, quindi --:--. Risparmio byte riutilizzando la routine di output o/!?l(riutilizzo anche quel mirror sia in entrata che in uscita). Uso più stack per memorizzare lo stato (ha output 12o --) e seleziono lo stato con cui dovrei produrre v>]?v.

^{Spiegazioni in arrivo! (1/2)}

HTML / CSS (solo Chrome), 80 + 4 = 84 byte

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

<tt>

Modifica : l'attributo "contenuto" non è animabile dalla specifica CSS , ma si trova sul browser desktop Chrome.

Noodel , non competitivo 16 byte

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

Noodel è ancora in fase di sviluppo. Sto solo cercando di bagnarmi i piedi con un paio di sfide.

Provalo:)

Come funziona

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

Ecco uno snippet di codice :)

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

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

QBasic purtroppo può dormire solo per interi secondi. Vedrò di ideare un metodo per consentire presto una maggiore flessibilità. Ho inserito 1 01per simulare .5.

Spiegazione:

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

Nelle build precedenti di QBIC, $e (spazio) erano caratteri riservati. Chiamare una funzione QBasic che richiedeva spazi (come sleep x) o $( left$(..)) richiedeva un codice letterale:

'QBASIC CODE`

Il codice in un blocco letterale di codice viene passato direttamente a QBasic senza essere analizzato da QBIC. Scaricando le funzioni da quei simboli (sono $diventati 'e le nuove righe ora sono ┘(alt-217) invece di ) i simboli non sono più visti da QBIC come caratteri speciali e semplicemente passati. Lo stesso vale per l'alfabeto minuscolo: è usato per rappresentare variabili numeriche sia in QBIC che in QBasic e rimane invariato. L'uso della funzionalità QBasic che non è implementata in QBIC (come SLEEP) è semplicemente una questione di non usare i caratteri riservati QBIC. Ciò è reso più semplice con le recenti modifiche ai simboli di comando.

JavaScript, 77 76 72 byte

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

Grazie a Lithos Kritixi per 1 byte e L. Serne per 4 byte!

Python 2, 88 85 73 71 byte

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

Provalo qui!

Prendendo in prestito l'idea di Stewie Griffin di sfogliare l'elenco, il programma è stato reso possibile. Versione non golfata con spiegazione:

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

Grazie @FlipTack per aver salvato 14 byte!

PHP, 51 50 47

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

1 byte salvato a causa di manatwork e altri 3 salvati da insertusernamehere. Grazie!

Pyth, 23 byte

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

In pseudocodice:

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

Utilizza la variabile preinizializzata Zcome flip-flop e inverte il suo stato ogni volta che iftenta di verificare la condizione.

rubino, 47 42 byte

Nessuna risposta ruby ​​ancora, quindi ecco il mio primo tentativo:

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

GNU sed, 39 byte

Modifiche:

• Swapped sleep e i12: 00 (per rendere il codice sorgente un po 'più bello)

golfed

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

spiegato

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.

Provalo online!

dc (bash), 37 byte

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

Funziona spingendo le due stringhe "12:00" e "-: -" sulla pila e quindi scambiando ripetutamente i valori, stampando l'elemento in cima alla pila e dormendo mezzo secondo.

Per eseguirlo, puoi salvarlo in un file e quindi digitare

nome file dc

oppure puoi eseguirlo direttamente dalla riga di comando bash digitando

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

Perl 6 ,  48 41  34 byte

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

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

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

Gelatina, 22 byte

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

Non funziona su TIO. Anche far funzionare Jelly su Android con QPython3 è stata un'esperienza divertente.

Spiegazione

®‘©ị“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 byte

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

Spiegazione

Clock[]

Emette una variabile di clock che cicla continuamente da 0 a 1 ogni secondo.

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

Se la variabile di clock è maggiore di 0,5, emettere "12:00". In caso contrario, emettere "-: -".

Dynamic@ ...

Rendi dinamico il programma (in costante aggiornamento)

Javascript, 57 55

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

2 byte salvati grazie a ETHproductions

Postscript 225 214

Solo per divertimento! Non inviarlo a una vera stampante !!

/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

Provalo:

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'

o

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

poi

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

Ma non provare ad aprirlo con un visualizzatore più sofisticato e preoccupati del desktop thumbnailer!

Javascript (nel browser), 174 160 159 122 112 112 111 109 107 66 (91) byte

Ho accettato preperché l'uso del font monotipato non fa parte dei requisiti, quindi il mio nuovo conteggio è 66 . Alcuni caratteri vengono aggiunti per utilizzare il carattere a spaziatura fissa ma poiché non è necessario, non conterò altri 25 caratteri.

Grazie a ETHproductions per il salvataggio di 14 byte,

a Kritixi Lithos per il salvataggio di 1 byte,

in manatwork per salvare 1 3 byte,

a Christoph per aver salvato altri due byte e

a me stesso per aver salvato 37 byte usando [..][b^=1]invece di setTimeout... e altri 10 sostituendo function(){..}con virgolette doppie ...

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

body{font-family:Courier}

... peggio:

Dal 66 a qualcosa in più ...

... ma per divertimento, nello spirito di un display lampeggiante:

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 punture (buonissimo)

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

Non avrei mai vinto comunque. QB non ha un floor () e inoltre non ha una funzione per dormire per x millisecondi. Pertanto, questo funziona afferrando la parte in virgola mobile del TIMER (restituisce i secondi trascorsi dalla mezzanotte, più una frazione del secondo corrente espresso come decimale a due cifre). Aggiungiamo quindi un "50 unità" ad anello per determinare quando la fase dovrebbe passare da "-: -" a "12:00" e utilizziamo il decimale TIMER originale per l'interruttore da "12:00" a "--:--".

Alla fine, anche eseguendo ciò rispettato in QB4.5, in DOSBox su una macchina piuttosto potente salterà i battiti. Questo perché il QB in realtà non è abbastanza veloce per eseguire il DO-LOOP e le valutazioni all'interno della SM in cui stiamo effettuando il confronto. Avrebbe bisogno di una scatola dal FUTURO!

Ad ogni modo, ora sembro 100, e ho reso felice ogni studente della American University poiché probabilmente hanno una risposta per la loro classe di scienze Comp - dal momento che stanno ancora insegnando questo ...

Clojure, 79 62 byte

V2

-17 byte passando da un terribile loop di indicizzazione al looping su un elenco infinito.

Crea un elenco infinito di "12:00"e si "--:--"ripete ancora e ancora, quindi utilizza doseqcostantemente per estrarre il messaggio successivo e stamparlo.

(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))))

Non riuscivo a pensare a un buon modo per compattare le costanti "12:00" e "-: -", quindi ho dovuto solo codificarle.

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 byte (non concorrenti)

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

Questa risposta fa uso delle due pile, girando tra loro, stampando i personaggi a turno:

`--:`    \ 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)

Il oWcomando fa parte di una serie di comandi sperimentali che postdatano la sfida, rendendo questa risposta non competitiva.

Windows PowerShell, 46 55 byte

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

Codice originale:

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