Muchos dispositivos electrónicos, especialmente los antiguos, mostrarán un parpadeo 12:00cuando no se haya configurado el tiempo. El propósito de este desafío es recrear esto.

Específicamente, la tarea es mostrar 12:00y, --:--alternativamente, en un bucle infinito .

El período debe ser de 1 segundo, dividido equitativamente en dos períodos de 0,5 segundos. Aquí "1 segundo" y "uniformemente" se pueden interpretar libremente. Por ejemplo, es aceptable si el código se detiene durante 0,5 segundos entre la visualización de las cadenas, incluso si el período resultante será un poco más alto que 1 segundo. Una pausa inicial antes de mostrar la primera cadena es aceptable.

Cada nueva cadena se puede mostrar reemplazando la cadena anterior o en una nueva línea . Se permite el espacio en blanco al final, excepto que si cada nueva cadena está en una línea diferente, no debería haber líneas vacías entre cadenas consecutivas.

El código más corto en bytes gana.

Jalea , 20 bytes

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

Cómo funciona

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

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

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

Editar: Guardado 23 bytes gracias a @insertusernamehere. Se guardó 1 byte al cambiar de <pre>a <tt>. Guardado 2 bytes gracias a @darrylyeo. Guardado 5 bytes gracias a @DBS.

Shell y pv26 bytes

Esto utiliza yesuna herramienta estándar y un pv elemento de tubería de Shell para medir los datos que pasan

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

Python2, 80 75 73 69 67 66 bytes

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

Noté que mi magia de cuerdas se hizo un poco más larga que elegir la cuerda de una matriz. No te preocupes, ya lo resolví.

Explicacion :

• Establecí un contador n a 0, que se alternará entre 0 y 1.

• Bucle sin fin con el bucle while 1.

• Creo una cadena 1-2-::0-0-, que contiene la cadena 12:00y se --:--superpone.

  • Comenzando desde el índice 0 con un paso de 2, obtenemos: 12:00

  • Comenzando desde el índice 1 con un paso de 2, obtenemos: --:--

• Utilizo n para hacer la secuencia repetida 0 , 1 , 0 , 1 , 0 ... que será el índice inicial de la cadena.

  • Usando n^=1, en cada bucle, obtenemos esa secuencia. ^siendo el operador XOR.
  • Si n == 0 -> n^=1resulta en 1
  • Si n == 1 -> n^=1da como resultado 0
• Imprimo la cadena y duermo ( .5-> 0.5) segundos.

¡@FlipTack ahorró 4 bytes! -> Pon el lazo en una línea.

¡@Rod ahorró 2 bytes! -> n+=1a n^=1, así n%2a n.

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

Octava, 63 62 61 55 bytes

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

¡Ahorré dos bytes gracias a Tom Carpenter! Usar una sola cadena en lugar de dos cadenas en una matriz de celdas fue más corto.

Explicación:

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

Se guardaron algunos bytes porque Octave no requiere dos puntos o punto flip(c)y coma entre y disp(), y entre pause(.5)y end.

JavaScript, 59 bytes

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

Explicación

setInterval('...',500) establece un intervalo para ejecutar código en la cadena cada 500 milisegundos, o 1/2 por segundo.

y=1establece una variable,, ya 1 inicialmente. De esa manera, lo primero que se imprime es 12:00porque yse usa para acceder a la matriz.

console.log(...)registra lo que sea en la consola, en este 12:00o --:--.

["12:00","--:--"][y^=1]crea una matriz con cadenas que contienen ambos estados. Luego, yse utiliza para acceder a uno de los elementos. Finalmente, ^=o el operador compuesto XOR lo hace y = y ^ 1. Esto simplemente invierte el bit porque 1 ^ 1es 0 y 0 ^ 1es 1, similar a lo que hizo @TuukkaX . De esta manera, la cadena registrada alterna entre los dos elementos en la matriz y, por lo tanto, crea el efecto de parpadeo.

V , 31 30 27 25 24 bytes

Ahorró 5 bytes gracias a @ nmjcman101 intercambiando el orden de 12:00y --:--para que kpueda eliminarse eliminando òpara que pueda agregarse implícitamente al final

Guardado 1 byte gracias a @DJMcMayhem al poner ambos 12:00y --:--en una línea

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

Antigua solución:

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

<ESC> es 0x1b

Hexdump:

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

Explicación

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

Nota: tengo resaltado activado

bash, 58 56 45 bytes

guardado 3 bytes al suprimir --después setya que 1st arg es un número.

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

Guardado 16 bytes usando la sintaxis de @DigitalTrauma :

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

Luego perdiendo 5 bytes debido al comentario de zeppelin .

Esto no se pudo probar en la línea de comando. Como involucramos $0, esto debe escribirse en un script para ejecutarse.

Desviar

Con un poco de preparación, esto podría ser bueno ( 412 bytes ):

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

O incluso las mismas dos líneas pero 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 bytes

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

Perl sleepno puede dormir por menos de 1 segundo, de ahí el uso de select undef, undef, undef, .5(golf reemplazado undefpor $,) para dormir .5 segundos.
Otra cosa interesante: $|solo puede contener 0o 1. Entonces $|--solo alterna su valor, de 0a 1.
Y finalmente, {... ;redo}actúa como un bucle infinito.

*> <> , 43 42 bytes

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

Pruébalo aquí!

Siento que debería poder hacer esto más corto, tengo un par de ideas para probar ... Básicamente, esto es una pila de :1200----. Aísla :y voltea la pila, insertando :en el medio de cualquiera ----o 1200(dependiendo de lo que esté al final de la pila).

También debo tener en cuenta que la única instrucción *> <> que usa es S(suspensión), de lo contrario, este es un programa>> adecuado.

Actualización: se guardó 1 byte desplazando :hacia la derecha en lugar de protegerlo con un registro.

Explicación

Inicialización

<v":1200----"

Aquí construimos la pila que usaremos durante la vida del programa.

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

Tiempo de salida

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

Esta es la sección donde se emite el tiempo. Los primeros 5 se envían a la pila, por lo que el ciclo siguiente se ejecuta 5 veces.

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"

Recuperar e intercambiar

S      >~r@@}r5

Aquí recuperamos la :posición de la que resulta después de la salida, y terminamos con una pila invertida. Esto en realidad sale muy bien en el "tiempo de salida", causando un bucle 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

Solución de 45 bytes

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

Pruébalo aquí!

Este también es básicamente un programa> <>.

Realmente pensé que sería capaz de guardar algunos bytes con este enfoque. Esto simplemente da salida 12:00, entonces --:--. Ahorro bytes reutilizando la rutina de salida o/!?l(incluso reutilizo ese espejo como entrada y salida). Utilizo múltiples pilas para almacenar el estado (tiene salida 12o --), y selecciono con qué estado debería salir v>]?v.

^{¡Explicaciones próximamente! (1/2)}

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

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

<tt>

Editar : El atributo "contenido" no es animable por la especificación CSS , pero está en el navegador de escritorio Chrome.

Noodel , 16 bytes no competitivos

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

Noodel sigue siendo un trabajo en progreso. Solo trato de mojarme los pies con un par de desafíos.

Intentalo:)

Cómo funciona

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

Aquí hay un fragmento de código :)

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

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

QBasic desafortunadamente solo puede dormir durante segundos completos. Veré sobre la creación de un método para permitir una mayor flexibilidad pronto. He ingresado 1 01para simular .5.

Explicación:

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

En versiones anteriores de QBIC, $y (espacio) eran caracteres reservados. Llamar a una función QBasic que necesitaba espacios (como sleep x) o $( left$(..)) requería un código literal:

'QBASIC CODE`

El código en un bloque literal de código se pasa directamente a QBasic sin que QBIC lo analice. Al descargar las funciones de esos símbolos (se $convirtió ', y las nuevas líneas ahora son ┘(alt-217) en lugar de ) los símbolos ya no son vistos por QBIC como caracteres especiales y simplemente se transmiten. Lo mismo es cierto para el alfabeto en minúsculas: se utiliza para representar variables numéricas en QBIC y QBasic y no se modifican. El uso de la funcionalidad QBasic que no se implementa en QBIC (como SLEEP) es simplemente una cuestión de no usar caracteres reservados QBIC. Esto se hace más fácil con los cambios recientes en los símbolos de comando.

JavaScript, 77 76 72 bytes

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

¡Gracias a Kritixi Lithos por 1 byte y L. Serne por 4 bytes!

Python 2, 88 85 73 71 bytes

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

Pruébalo aquí!

Al tomar prestada la idea de Stewie Griffin de voltear la lista, el programa fue posible. Versión sin golf con explicación:

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

¡Gracias @FlipTack por guardar 14 bytes!

PHP, 51 50 47

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

1 byte guardado debido a trabajo en equipo y otros 3 guardados por insertusernamehere. ¡Gracias!

Pyth, 23 bytes

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

En pseudocódigo:

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

Utiliza la variable preinicializada Zcomo flip-flop e invierte su estado cada vez que ifintenta verificar la condición.

rubí, 47 42 bytes

Aún no hay respuesta de ruby, así que aquí está mi primer intento:

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

GNU sed, 39 bytes

EDICIONES:

• Intercambiado sueño y i12: 00 (a código fuente hacen parecer un poco más agradable)

Golfed

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

Explicado

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.

¡Pruébelo en línea!

dc (bash), 37 bytes

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

Esto funciona presionando las dos cadenas "12:00" y "-: -" en la pila y luego intercambiando repetidamente los valores, imprimiendo el elemento en la parte superior de la pila y durmiendo medio segundo.

Para ejecutar esto, puede guardarlo en un archivo y luego escribir

dc nombrearchivo

o puede ejecutarlo directamente desde la línea de comando bash escribiendo

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

Perl 6 ,  48 41  34 bytes

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

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

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

Jalea, 22 bytes

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

No funciona en TIO. Hacer que Jelly se ejecute en Android con QPython3 también fue una experiencia divertida.

Explicación

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

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

Explicación

Clock[]

Emite una variable de reloj que realiza ciclos continuos de 0 a 1 cada segundo.

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

Si la variable del reloj es mayor que .5, envíe "12:00". Si no, salida "-: -".

Dynamic@ ...

Hacer el programa dinámico (actualizando constantemente)

Javascript, 57 55

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

2 bytes guardados gracias a ETHproductions

Posdata 225 214

¡Solo por diversión! ¡No envíes esto a una impresora real!

/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

Intentalo:

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

luego

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

¡Pero no intente abrir esto con un visor más sofisticado y preocúpese por la miniatura del escritorio!

Javascript (en el navegador), 174 160 159 122 112 111 109 107 66 (91) bytes

Lo he tomado preporque usar una fuente monotipada no es parte del requisito, por lo que mi nuevo recuento es 66 . Se agregan algunos caracteres para usar fuentes monoespaciadas, pero como no es necesario, no contaré estos 25 caracteres más.

Gracias a ETHproductions por guardar 14 bytes,

a Kritixi Lithos para ahorrar 1 byte,

para trabajar para ahorrar 1 3 byte,

a Christoph por guardar dos bytes más y

a mí mismo por ahorrar 37 bytes usando en [..][b^=1]lugar de setTimeout... y 10 más reemplazando function(){..}por comillas dobles ...

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

body{font-family:Courier}

... peor:

De 66 a algo más ...

... pero por diversión, en el espíritu de una pantalla parpadeante:

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

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

Nunca iba a ganar de todos modos. QB no tiene un piso (), y tampoco tiene una función para dormir durante x milisegundos. Por lo tanto, esto funciona agarrando la parte de coma flotante del TEMPORIZADOR (devuelve los segundos transcurridos desde la medianoche, más una fracción del segundo actual expresado como un decimal de dos dígitos). Luego le agregamos un "ciclo de 50 unidades" para determinar cuándo la fase debe cambiar de "-: -" a "12:00", y usar el decimal TEMPORIZADOR original para el cambio de "12:00" a "--:--".

Finalmente, incluso ejecutar esto cumplió en QB4.5, en DOSBox en una máquina bastante poderosa omitirá los ritmos. Esto se debe a que QB realmente no es lo suficientemente rápido como para realizar el DO-LOOP y las evaluaciones dentro de la MS en la que estamos haciendo la comparación. ¡Necesitaría una caja del FUTURO!

De todos modos, ahora parezco 100, e hice felices a todos los estudiantes de la Universidad Americana, ya que probablemente tengan una respuesta para su clase de Comp Sci, ya que todavía están enseñando esto ...

Clojure, 79 62 bytes

V2

-17 bytes cambiando de un horrible ciclo de indexación a un ciclo en una lista infinita

Crea una lista infinita de "12:00"y "--:--"repitiendo una y otra vez, luego usa doseqpara extraer constantemente el siguiente mensaje e imprimirlo.

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

No podía pensar en una buena manera de compactar las constantes "12:00" y "-: -", así que tuve que codificarlas.

Sin golf:

(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 bytes (no competidor)

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

Esta respuesta hace uso de las dos pilas, volteando entre ellas, imprimiendo los caracteres a su vez:

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

El oWcomando es parte de un conjunto de comandos experimentales que son posteriores al desafío, lo que hace que esta respuesta no sea competitiva.

Windows PowerShell, 46 55 bytes

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

Código original

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