Piscando doze

43

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.

Luis Mendo
fonte
1
isso conta como complexidade kolmogorov ?
FlipTack
@FlipTack Acho que sim, mas não tinha certeza. Pensamentos, alguém?
Luis Mendo
@LuisMendo Acho que não, acho que a tag KG é principalmente para uma string fixa. Isso tem mais, as seqüências de espera e alternadas.
Rɪᴋᴇʀ
Os envios podem esperar 0,5 segundos antes de mostrar a saída inicial?
FlipTack
1
IMHO, a declaração "Cada nova string pode ser exibida substituindo a string anterior ou em uma nova linha" tornou esse desafio não divertido.
Setop

Respostas:

4

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.
Dennis
fonte
Então você está basicamente transformando as duas strings da lista em links próprios, com um comando de suspensão adicional? Doce.
precisa saber é o seguinte
32

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.

Neil
fonte
1
@insertusernamehere Bah, eu golfed afastado o a{position:absolute}, mas esqueci completamente sobre o pre...
Neil
Você ainda precisa da pré tag? o css menciona apenas a.
Ev3commander
@ ev3commander Salvei um byte mudando para <tt>.
Neil
Você pode remover a final }}completamente.
darrylyeo
Eu acho que você deve ser capaz de simplificar margin-lefta margindesde que você está trabalhando a partir do canto superior esquerdo de qualquer maneira margin:-5ch;deve ter o mesmo efeito.
DBS
15

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
F. Hauri
fonte
2
Solução agradável, mas a linguagem provavelmente deve ser declarada como "Shell e pv", pois (que eu saiba, de qualquer maneira) pv não está incluído em nenhum shell nem faz parte dos principais utilitários do GNU ou BSD.
Mitchell Spector
1
Que truque legal! (que acredito ter sido pioneira no @Digital Trauma aqui ). Embora neste caso pareça um pouco contra o espírito do desafio, pois a declaração de missão era "exibir 12:00 e -: - alternativamente" (imitando uma exibição piscando), mas esse código apresentará apenas caractere por caractere a uma taxa constante de 12 caracteres por segundo. O que significa que "12:00" permanecerá na tela apenas por 1/12 (0,08) segundos ("12: 0 _" = 1 / 12s => "12:00" = 2 / 12s => "-").
Zeppelin
@ zeppelin obrigado por referências: Eu usei a amostra do @ DigitalTrauma -qlL2para fazer 2 linhas por segundo em vez de -qL12: 12 caracteres por segundo. Comprimento do roteiro é o mesmo
F. Hauri
15

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)].

Yytsi
fonte
7
você pode substituir n+=1e n^=1, em seguida [n::2], usar , salva 2 bytes e evita grandes números c:
Rod
4
se você alterar o print"1-2-::0-0-"[n::2]que print"\b"*6+"1-2-::0-0-"[n::2],ele irá adicionar alguns bytes, mas ele vai piscar no lugar
zumbido
1
@Buzz que você pode usar em \rvez de \b\b\b...ir para o início da linha. Mas de qualquer maneira, isso adicionaria apenas bytes à solução atual.
FlipTack
Você pode salvar um byte fazendo while[time.sleep(.5)]:.
Xnor
@xnor Eu tinha tanta certeza que não podia jogar mais. Este site continua a me surpreender. Obrigado!
Yytsi 7/01
15

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.

Stewie Griffin
fonte
1
Boa idéia para usar em flipvez de um contador!
Luis Mendo
11

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.

Andrew Li
fonte
Conseguiu salvar um byte com este:y=1;setInterval('console.log(y?"12:00":"--:--");y=!y',500)
woutr_be 3/17/17
Ponta ETHproductions a minha resposta: You can save some bytes with setInterval(...,i=500) :-). Basicamente, temos a mesma resposta e funciona para a sua também.
Christoph
11

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

giff

Kritixi Lithos
fonte
7
Você levou a piscar , literalmente, em que gif :-)
Luis Mendo
O segundo òé fornecido implicitamente, para que você possa removê-lo.
DJMcMayhem
@DJMcMayhem Por algum motivo, ele não funciona sem o segundo ò. Ele só é executado uma vez
Kritixi Lithos
2
Troque a ordem de suas entradas para não precisar da primeira k. Então, em vez de pkddvocê pode apenas usar Vp, pois pno modo de seleção visual efetivamente alterna a seleção com o registro padrão.
precisa saber é o seguinte
1
Eu sei que você tem problemas para remover o ò, mas se isso funcionar agora, acho que você poderá alterá-lo para òVp:sl500me deixar o V adicionar o ^Mòpor 2 bytes.
precisa saber é o seguinte
11

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|                                      
                                                                               '
F. Hauri
fonte
3
s(){ echo $1;sleep .5;};for((;;)){ s 12:00;s --:--;}
manatwork
2
@manatwork Nice! Eu acho que não é o mesmo script! Você precisa publicá-los como resposta!
F. Hauri 02/01
Tenho que admitir que a arte ASCII é absolutamente deslumbrante ... Você usou uma ferramenta para criá-la ou a criou manualmente?
ETHproductions
2
@ETHproductions eu uso Ghostscript : printf '%%\041\n/Helvetica findfont\n24 scalefont\nsetfont\nnewpath\n%s %s moveto\n(%s) show\nshowpage\n' -2.456 0.550003 12:00 | gs -sDEVICE=pnmraw -r600 -g470x146 -sOutputFile=- -q - | pnmscale -width 160 | ppmtopgm | pgmtopbm | pbmtoascii -2x4;-)
F. Hauri
1
... ouf()(echo $1;sleep .5);f 12:00;f --:--;$0
Trauma digital
9

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.

dada
fonte
6

*> <> , 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)

redstarcoder
fonte
6

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.

degif
fonte
1
Parece ser específico do Chrome. Pelo menos não funciona no Firefox. Isso não é um problema, a solução ainda é válida, seria bom especificá-la.
Manatwork
6

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>

tkellehe
fonte
2
Se o intérprete pós-data do desafio, marque-o como "não concorrente" :). Noodel parece legal, definitivamente, verificando-o.
Redstarcoder # 1
@redstarcoder Oops! Obrigado, esqueci de colocar isso.
precisa saber é
Você pode explicar a codificação? Ele soma muito mais que 16 no UTF-8.
precisa saber é o seguinte
1
Eu olhei para o seu link, ele não explica a codificação. Veja bem, nem todos os caracteres têm 1 byte por "padrão" (UTF-8). Especifique uma codificação existente ou faça uma, caso contrário, essa é uma contagem de bytes incorreta. Deve haver um meta post em algum lugar sobre isso. A menos que você defina uma codificação, este é UTF-8 e tem 22 bytes. @tkellehe
devRicher
1
Encontrado o meta post , btw.
precisa saber é o seguinte
5

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.

steenbergh
fonte
4

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!

binazy010
fonte
1000pode ser encurtado para1e3
Kritixi Lithos
2
setIntervale setTimeoutaceite uma string com código como primeiro argumento, para que você possa salvar outro 4B: setInterval('l=console.log,l("12:00"),setTimeout("l(-: -)",500)',1e3)
Luke
O `s significa que agora é ES6, enquanto a resposta anterior só precisava do ES5.
Neil
4

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!

Anthony Pham
fonte
1
Você pode golfe-lo ainda mais curto usando corte corda, como esta
FlipTack
4

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!

Christoph
fonte
1
Se você mover a usleep(5e5)chamada para foro terceiro parâmetro da, o ,separador se tornará desnecessário, salvando 1 caractere.
Manatwork
@manatwork thanks! Eu tinha while(1)no começo.
Christoph
2
Você pode economizar mais 3 bytes : Remova o espaço em branco entre echoe $ie substituir \ncom uma nova linha real.
precisa saber é o seguinte
@insertusernamehere, mesmo no golfe, isso machuca meus olhos: D, mas ei, isso funciona.
Christoph
3

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.

busukxuan
fonte
coloque .d5 na frente do loop e remova a citação final
Maltysen 12/01
3

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}
SztupY
fonte
3

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!

zepelim
fonte
3

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'

Mitchell Spector
fonte
3

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*
Brad Gilbert b2gills
fonte
usar um forloop pode torná-lo um pouco mais curto:for |<12:00 --:-->xx* {sleep .5;.say}
smls 15/01
Ainda mais curto se você usar o fato de sayretornar 1:sleep .say/2 for |<12:00 --:-->xx*
smls 15/01
2

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. 
PurkkaKoodari
fonte
1
Isso dorme? Você pode adicionar uma explicação?
steenbergh
1
@steenbergh Adicionado. Desculpe o atraso, a edição desses recuos para a explicação é um pouco difícil no aplicativo SE com uma fonte não monoespaçada.
precisa saber é o seguinte
2

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)

JungHwan Min
fonte
2

Javascript, 57 55

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

2 bytes economizados graças ao ETHproductions

Christoph
fonte
3
Você pode salvar alguns bytes com setInterval(...,i=500):-)
ETHproductions
2

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!

F. Hauri
fonte
Se gs -c '...'comando solicitará uma página em branco, você pode ter a crescer a janela de exibição ou usar uma resolução menor: gs -r45 -c '...'ou papersize menorgs -r600 -g360x200 -c '...'
F. Hauri
2

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>

F. Hauri
fonte
1
1000pode se tornar1e3
Kritixi Lithos
1
Você pode salvar um monte de bytes removendo todas as instâncias de window.; window.setTimeouté o mesmo que setTimeout.
ETHproductions
1
tté menor que pree também implica o uso de fonte monoespaçada. (Apenas é elemento inline, não bloco, mas isso deve fazer nenhuma diferença aqui.)b=document.body.append(a=document.createElement('tt'))
manatwork
1
d=document;d.body.append(a=d.createElement('tt'));setInterval("a.innerHTML=++b%2?'12:00':'--:--'",b=500)salva 5 bytes
Christoph
1
Existe um motivo para gerar um elemento? setInterval("document.body.innerHTML=++b%2?'12:00':'--:--'",b=500)apenas fica abaixo do monoespaço sofisticado, mas tem apenas 66 bytes.
Christoph
2

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

Robert Lerner
fonte
Você pode remover alguns dos espaços? ou seja, b% = b% - 99para b%=b%-99?
Rɪᴋᴇʀ
Sim, eu tenho certeza que pude, mas usei o IDE original que, depois de pressionar enter no final da linha, os adicionaria novamente. Eu teria que editá-lo fora do IDE no DOS e, em seguida, descubra os parâmetros para o vinculador / compilador para verificar se minha solução ainda funcionou ... Portanto, pode ser mais curta, mas não dentro do meu esforço.
Robert Lerner
Bem, você precisa jogar este código de golfe, caso contrário, não é uma resposta válida e será excluída. Me desculpe por isso. (Eu entendo completamente o que quer dizer, mas a comunidade como um todo decidiu contra respostas não golfed)
Rɪᴋᴇʀ
Bom ponto, vou remover os espaços.
Robert Lerner
2

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
Carcinigenicado
fonte
2

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.

FlipTack
fonte
2

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.
Macky Clemen
fonte