Muitos dispositivos eletrônicos, especialmente os antigos, irão piscar 12:00quando a hora ainda não foi definida. O objetivo deste desafio é recriar isso.

Especificamente, a tarefa é exibir 12:00e, --:--alternativamente, em um loop infinito .

O período deve ser de 1 segundo, dividido igualmente em dois períodos de 0,5 segundos. Aqui "1 segundo" e "uniformemente" podem ser interpretados livremente. Por exemplo, é aceitável se o código parar por 0,5 segundos entre a exibição das seqüências, mesmo que o período resultante seja um pouco maior que 1 segundo. Uma pausa inicial antes de exibir a primeira string é aceitável.

Cada nova sequência pode ser exibida substituindo a antiga ou em uma nova linha . O espaço em branco à direita é permitido, exceto que se cada nova string estiver em uma linha diferente, não haverá linhas vazias entre as seqüências consecutivas.

O menor código em bytes vence.

Gelatina , 20 bytes

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

Como 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: salvou 23 bytes graças a @insertusernamehere. Economizou 1 byte alternando de <pre>para <tt>. Guardado 2 bytes graças a @darrylyeo. Economizou 5 bytes graças ao @DBS.

Shell e pv, 26 bytes

Utiliza a yesferramenta padrão e o pv elemento de pipeline da Shell para medir dados que passam

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

Percebi que minha mágica das cordas ficou um pouco mais longa do que pegar a corda de uma matriz. Deixa pra lá, descobri.

Explicação :

• Defino um contador n como 0, que será alternado entre 0 e 1.

• Eu loop infinitamente com o loop while 1.

• Eu crio uma string 1-2-::0-0-, que contém a string 12:00e --:--interpolada.

  • Começando no índice 0 com uma etapa 2, obtemos: 12:00

  • Começando no índice 1 com uma etapa 2, obtemos: --:--

• Uso n para criar a sequência repetida 0 , 1 , 0 , 1 , 0 ... que será o índice inicial da string.

  • Usando n^=1, em cada loop, obtemos essa sequência. ^sendo o operador XOR.
  • Se n == 0 -> n^=1resultar em 1
  • Se n == 1 -> n^=1resultar em 0
• Imprimo a sequência e durmo ( .5-> 0.5) segundos.

O @FlipTack salvou 4 bytes! -> Coloque o loop em uma linha.

@Rod economizou 2 bytes! -> n+=1para n^=1, assim n%2para n.

@xnor salvou um byte! -> while 1-> while[time.sleep(.5)].

Oitava, 63 62 61 55 bytes

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

Economizou dois bytes graças a Tom Carpenter! O uso de uma única sequência em vez de duas em uma matriz de células foi mais curto.

Explicação:

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

Poucos bytes salvos porque o Octave não requer dois pontos ou vírgulas entre flip(c)e disp(), e entre pause(.5)e end.

JavaScript, 59 bytes

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

Explicação

setInterval('...',500) define um intervalo para executar o código na cadeia a cada 500 milissegundos ou 1/2 por segundo.

y=1define uma variável,, ypara 1 inicialmente. Dessa forma, a primeira coisa que é impressa é 12:00porque yé usada para acessar a matriz.

console.log(...)registra o que quer que seja para o console, neste 12:00ou --:--.

["12:00","--:--"][y^=1]cria uma matriz com cadeias contendo os dois estados. Então, yé usado para acessar um dos elementos. Finalmente ^=,, ou o operador composto XOR faz y = y ^ 1. Isso apenas inverte o bit porque 1 ^ 1é 0 e 0 ^ 1é 1, semelhante ao que o @TuukkaX fez . Dessa forma, a cadeia registrada alterna entre os dois elementos na matriz e, assim, cria o efeito piscante.

V , 31 30 27 25 24 bytes

Salvei 5 bytes graças a @ nmjcman101, trocando a ordem de 12:00e --:--para que ele kpossa ser removido, removendo qualquer, òpara que ele possa ser adicionado implicitamente no final

Salvo 1 byte graças a @DJMcMayhem, colocando ambos 12:00e --:--em uma linha

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

Solução antiga:

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

Explicação

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

Nota: tenho destaque ativado

bash, 58 56 45 bytes

salvou 3 bytes suprimindo --depois, setpois o 1º arg é um número.

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

Salva 16 bytes usando a sintaxe de @DigitalTrauma :

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

Perdendo 5 bytes por causa do comentário do zeppelin .

Isso não pôde ser testado na linha de comando. Como envolvemos $0, isso deve ser escrito em um script para ser executado.

Desviar

Com um pouco de preparação, isso pode se tornar interessante ( 412 bytes ):

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

Ou até as mesmas duas linhas, mas com:

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}

Os Perl sleepnão conseguem dormir por um período abaixo de 1 segundo, daí o uso de select undef, undef, undef, .5(golfe substituindo undefpor $,) para dormir 0,5 segundo.
Outra coisa interessante: $|só pode segurar 0ou 1. Então, $|--apenas alterna seu valor, de 0para 1.
E, finalmente, {... ;redo}age como um loop infinito.

*> <> , 43 42 bytes

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

Experimente aqui!

Eu sinto que deveria ser capaz de reduzir isso, tenho algumas idéias para tentar ... Basicamente, isso gera uma pilha de :1200----. Ele isola :e vira a pilha, inserindo-a :no meio de uma ----ou outra 1200(dependendo do que estiver no final da pilha).

Devo observar também que a única instrução *> <> usada é S(suspensão), caso contrário, este é um programa> <> adequado.

Atualização: salvou 1 byte deslocando o :para a direita em vez de protegê-lo com um registro.

Explicação

Inicialização

<v":1200----"

Aqui construímos a pilha que usaremos para a vida útil do programa.

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

Tempo de saída

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

Esta é a seção em que o tempo é realmente gerado. Os primeiros 5 são empurrados para a pilha, de modo que o loop abaixo saiba executar 5 vezes.

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 trocar

S      >~r@@}r5

Aqui recuperamos a :posição que resulta após a saída e terminamos com uma pilha invertida. Na verdade, isso sai muito bem no "tempo de saída", causando um loop 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

Solução de 45 bytes

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

Experimente aqui!

Este também é basicamente um programa> <>.

Eu realmente pensei que seria capaz de salvar alguns bytes com esta abordagem. Isso simplesmente resulta 12:00, então --:--. Eu salvo bytes reutilizando a rotina de saída o/!?l(eu até reutilizo esse espelho como entrada e saída). Utilizo várias pilhas para armazenar o estado (tem saída 12ou --) e seleciono com qual estado devo sair v>]?v.

^{Explicações em breve! (1/2)}

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

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

<tt>

Editar : o atributo "content" não pode ser animado pela especificação CSS , mas está no navegador da área de trabalho do Chrome.

Noodel , 16 bytes não- concorrentes

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

Noodel ainda é um trabalho em andamento. Apenas tentando me molhar com alguns desafios.

Tente:)

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

Aqui está um trecho 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?@--:--

Infelizmente, o QBasic só pode dormir por segundos inteiros. Vou ver sobre a criação de um método para permitir mais flexibilidade em breve. Eu inseri 1 como 01para simular .5.

Explicação:

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

Nas versões mais antigas do QBIC, $e (espaço) eram caracteres reservados. Chamar uma função QBasic que precisava de espaços (como sleep x) ou $( left$(..)) exigia um literal de código:

'QBASIC CODE`

O código em um bloco literal de código é passado diretamente para o QBasic sem ser analisado pelo QBIC. Ao descarregar funções desses símbolos ( $tornou-se 'e as novas linhas agora são ┘(alt-217) em vez de ), os símbolos não são mais vistos pelo QBIC como caracteres especiais e simplesmente transmitidos. O mesmo se aplica efetivamente ao alfabeto minúsculo: é usado para representar variáveis ​​numéricas no QBIC e no QBasic e permanece inalterado. O uso da funcionalidade QBasic que não é implementada no QBIC (como SLEEP) é simplesmente uma questão de não usar caracteres reservados do QBIC. Isso é facilitado com as alterações recentes nos símbolos de comando.

JavaScript, 77 76 72 bytes

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

Agradecimentos a Kritixi Lithos por 1 byte e 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)

Experimente aqui!

Emprestando a idéia de Stewie Griffin de inverter a lista, o programa foi possível. Versão ungolfed com explicação:

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

Obrigado @FlipTack por salvar 14 bytes!

PHP, 51 50 47

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

1 byte salvo devido ao trabalho manual e outros 3 salvos por insertusernamehere. Obrigado!

Pitão, 23 bytes

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

No pseudocódigo:

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

Usa a variável pré-inicializada Zcomo flip-flop e inverte seu estado toda vez que iftenta verificar a condição.

ruby, 47 42 bytes

Nenhuma resposta ruby ​​ainda, então aqui está minha primeira tentativa:

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

GNU sed, 39 bytes

EDITAR% S:

• Troca de sono e i12: 00 (para tornar o código fonte um pouco melhor)

Golfe

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.

Experimente Online!

dc (bash), 37 bytes

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

Isso funciona pressionando as duas seqüências de caracteres "12:00" e "-: -" na pilha e trocando os valores repetidamente, imprimindo o item na parte superior da pilha e dormindo meio segundo.

Para executar isso, você pode salvá-lo em um arquivo e digitar

nome do arquivo dc

ou você pode executá-lo diretamente na linha de comando do bash digitando

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*

Gelatina, 22 bytes

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

Não funciona no TIO. Fazer o Jelly rodar no Android com o QPython3 também foi uma experiência divertida.

Explicação

®‘©ị“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","--:--"]

Explicação

Clock[]

Emite uma variável de clock que alterna continuamente de 0 a 1 a cada segundo.

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

Se a variável do relógio for maior que 0,5, digite "12:00". Caso contrário, imprima "-: -".

Dynamic@ ...

Torne o programa dinâmico (atualizando constantemente)

Javascript, 57 55

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

2 bytes economizados graças ao ETHproductions

Postscript 225 214

Apenas por diversão! Não envie isso para uma impressora 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

Tente:

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

então

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

Mas não tente abrir isso com um visualizador mais sofisticado e se preocupe com o miniaturizador da área de trabalho!

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

Eu pedi preporque o uso de fonte monotipada não faz parte do requisito, então minha nova contagem é 66 . Alguns caracteres são adicionados para usar fonte monoespaçada, mas como isso não é necessário, não contarei mais 25 caracteres.

Graças à ETHproductions por economizar 14 bytes,

ao Kritixi Lithos por economizar 1 byte,

para manatwork para guardar um 3 bytes,

a Christoph por salvar mais dois bytes e

para mim mesmo por salvar 37 bytes usando em [..][b^=1]vez de setTimeout... e mais 10 substituindo function(){..}por aspas duplas ...

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

body{font-family:Courier}

... pior:

De 66 a algo mais ...

... mas por diversão, no espírito de uma tela piscando:

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

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

Eu nunca iria ganhar de qualquer maneira. O QB não possui um piso () e também não tem uma função para dormir por x milissegundos. Portanto, isso funciona agarrando a parte do ponto flutuante do TIMER (retorna segundos decorridos desde a meia-noite, mais uma fração do segundo atual expressa como um decimal de dois dígitos). Em seguida, adicionamos um loop em torno de "50 unidades" para determinar quando a fase deve mudar de "-: -" para "12:00" e usamos o decimal TIMER original para a mudança de "12:00" para "--:--".

Por fim, mesmo executando isso em conformidade com o QB4.5, o DOSBox em uma máquina bastante poderosa ignorará as batidas. Isso porque o QB realmente não é rápido o suficiente para realizar o DO-LOOP e as avaliações dentro do MS em que estamos fazendo a comparação. Precisaria de uma caixa do FUTURE!

Enfim, agora pareço 100 e deixei todos os estudantes da Universidade Americana felizes, pois provavelmente têm uma resposta para a aula de ficção científica - já que ainda estão ensinando isso ...

Clojure, 79 62 bytes

V2

-17 bytes, passando de um loop de indexação horrível para loop em uma lista infinita.

Cria uma lista infinita de "12:00"e "--:--"repetir uma e outra vez, então usa doseqpara puxar constantemente a mensagem seguinte, e imprimi-lo.

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

Não consegui pensar em uma boa maneira de compactar as constantes "12:00" e "-: -", então tive que codificá-las.

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 bytes (não concorrente)

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

Esta resposta faz uso das duas pilhas, alternando entre elas, imprimindo os caracteres por sua 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)

O oWcomando faz parte de um conjunto de comandos experimentais que pós-datam o desafio, tornando essa resposta não 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.