Sua tarefa é criar um programa que imite o Big Ben (Twitter) .

Tarefa

Sempre que uma nova hora começa (de acordo com a hora local do seu computador ou com o UTC), é necessário gerar tempos BONGrepetidos hour(com um espaço entre as palavras). Por exemplo, quando são 3 horas, você precisa emitir BONG BONG BONG. O formato da hora segue o formato das 12 horas, ou seja, depois das 12 horas, temos 1 e não 13. O programa / função deve ser executado para sempre.

Exemplo:

^{não produza coisas dentro dos colchetes}

(start: 00:34 for example)
BONG               (01:00)
BONG BONG          (02:00)
(...)
BONG BONG BONG BONG BONG BONG BONG BONG BONG BONG BONG BONG (12:00)
BONG               (01:00 again)
(...)
(it continues forever)

Regras

• Cada série de BONGs deve ser separada por uma nova linha
• Novas linhas iniciais / finais são permitidas
• No entanto, espaços à esquerda / à direita não são permitidos
• O envio deve ser executado para sempre
• Sua saída pode ser impressa em ± 3 segundos desde o início da hora
• Você não pode presumir que o programa seja executado a qualquer hora específica

Isso é código-golfe , então o programa com o menor número de bytes vence!

05AB1E , 43 bytes

3600žcžb60*+->Lvw}["BONG "ža<12%>×,5°36*.W]

Experimente online! (lol, isso não funcionará, o tempo limite será excedido em 60 segundos. Faça o download do interpretador 05AB1E para isso)

Explicação:

3600žcžb60*+->                          # Get amount of seconds (plus one) until next hour
              Lvw}                      # Wait said amount of seconds
                  [                     # Infinite loop start
                   "BONG "ža<12%>×,     # Print "BONG " multiplied by the amount of hours (12-hour clock)
                               5°36*.W  # Wait an hour (3600000 milliseconds)
                                      ] # Infinite loop end  

Demorei um pouco para jogar golfe! Talvez eu consiga jogar um pouco mais, mas é melhor do *><>que isso, então é legal :)

Versão rápida:

1Uw["BONG "X<12%>×,wX>U]

Esperará um segundo no início e um segundo entre os BONGs

Bater, 71, 70, 69 bytes

EDITAR% S:

• Otimizou um pouco o cálculo do intervalo de suspensão, -1 byte;
• Backticks substituídos por xargs, -1 byte (Obrigado @ jrtc27!).

Golfe

sleep `date +3600-%s%3600|bc`;yes BONG|sed $(date +%I)q|xargs;exec $0

Explicado

#Compute the number of seconds left in the current hour and wait.
sleep `date +3600-%s%3600|bc`; 

#Print "hour" (1-12) worth of "BONG" strings, one per line,
#use xargs to merge them into a single space-separated string.
yes BONG|sed $(date +%I)q|xargs

#Re-execute itself (in the same process).
exec $0

Versão de teste

Funciona com minutos em vez de horas

sleep `date +60-%s%60|bc`;yes BONG|sed $(date +%I)q|xargs;exec $0

*> <> , 48 47 44 bytes

>s?um?uhc%:?!c21.O
v$o" GNOB"oooo$1-:?!
\aofS

Experimente aqui! ( ou esta versão que faz isso a cada minuto para teste )

Isso gera um número de BONGs separados por espaços com base em que hora é (e 13 é 1, etc). Não há espaço à direita após a final BONGe há uma nova linha à direita.

Tecnicamente, isso não dura para sempre (mas basicamente). Ele vaza ~ 28 bytes por dia (ignorando a sobrecarga do intérprete ...). Levaria ~ 105062 anos para vazar 1GiB.

Aproximando-se da sobrecarga do intérprete, a pilha é apenas uma fatia de float64s no intérprete Golang. Então, eu simplesmente 28*8criei 224 bytes por dia. Dividi esse número pelo número de bytes em um gibibyte (1073741824) e 365 para aproximar que levaria 13132,85 anos para vazar 1 GiB.

Nota sobre os intérpretes

O intérprete online está em Javascript. A página deve estar aberta e visível para verificar a hora atual e emitir os BONGs. O intérprete Golang não tem essa limitação.

Explicação

Main loop:

s?um?u          O     if seconds == 0 && minutes == 0:
      hc%               push hours % 12 (bongs) to the stack
         :?!c           if bongs is 0, push 12 to the stack
             21.        jump to "output bongs" coords (2, 1)


Output bongs:

Begins at `"` because of the jump.

   " GNOB"            push "BONG " to the stack
          oooo        output "BONG"
              $1-     subtract 1 from bongs
v                :?!  if bongs == 0, move to "newline and sleep"
 $o                   output " "


Newline and sleep:

\                     mirror the IP to the right
 ao                   output a newline
   fS                 sleep for 1.6s
\                     mirror to main loop

JavaScript (ES6), 99 93 bytes

f=_=>setTimeout('alert("BONG ".repeat(new Date/36e5%12|0||12).trim(f()))',36e5-new Date%36e5)

Isso usa a hora UTC (que se alinha com a coisa real). Devido à natureza não testável do código, você pode tentar o seguinte, que faz a mesma coisa, mas a cada 60 segundos:

f=_=>setTimeout('alert("BONG ".repeat(new Date/36e5%12|0||12).trim(f()))',6e4-new Date%6e4)

f()

Aqui está uma versão bônus de 99 bytes que usa a hora local:

f=_=>setTimeout('alert("BONG ".repeat(new Date().getHours()%12||12).trim(f()))',36e5-new Date%36e5)

JavaScript (ES6), 125 123 117 115 bytes

Obrigado a @ Flp.Tkc por salvar 5 bytes!

Agradecemos a @BenAston por salvar mais 2 bytes!

a=eval(b=`(new Date).getHours()`);setInterval(w=>eval(b)!=a?console.log(Array(++a%12+1).join`BONG `.trim()):"",1e3)

Snack Snippet

a=eval(b=`(new Date).getHours()`);setInterval(w=>eval(b)!=a?console.log(Array(++a%12+1).join`BONG `.trim()):"",1e3)

Lote, 142 bytes

@timeout/t>nul 1
@if not %time:~3,5%==00:00 %0
@set/ah=-%time:~0,2%%12
@set s=............
@call set s=%%s:~%h%%%
@echo %s:.=BONG %
@%0

Como o arquivo é executado como um loop infinito, inicio com um atraso de 1s, pois preciso de um após os bongos, e isso salva os ciclos da CPU. Ele >nulé posicionado com cuidado para salvar um byte ( 1>nulfaria com que o 1 fosse consumido pelo redirecionamento). Em seguida, fazemos um loop até que os minutos e os segundos sejam zero. Os bongos são construídos utilizando o módulo de hora negativo 12 e solicitando os últimos hcaracteres de uma sequência de 12 caracteres. Quando hé zero, isso nos dá a cadeia inteira, portanto, 12 bongos. Basta substituir os caracteres pela palavra BONG. Quando executado, é algo parecido com isto (observe que a imagem não se repete, portanto, você precisará forçar o recarregamento para ver a animação novamente):

Bash + Linux crontab, 90

Eu esperava que isso fosse mais curto do que as outras respostas do shell. Ainda assim, acho que é uma abordagem interessante:

for i in {0..11};{
s+=\ BONG
echo "0 $i,$[i+12] * * * echo$s>/proc/$PPID/fd/1"
}|crontab -

O script é executado uma vez, preenche o crontab e sai. No entanto, a saída dos cronjobs é enviada para o terminal a partir do qual o script foi executado. Eu acho que isso satisfaz o envio deve ser executado para sempre requisito.

Aviso - isso limpará todas as entradas existentes do crontab, portanto, verifique se você possui as cópias de segurança existentes.

Isso funciona no Ubuntu 16.04, que está usando o Vixie cron por padrão.

Ruby, 112 99 Bytes

loop{sleep 2;n=Time.now;if(n.min==0);puts ('BONG '*n.strftime('%I').to_i).chop;sleep 60-n.sec end}

Versão antiga

loop{sleep(2);n=Time.now; if(n.min.zero?) then puts ('BONG ' * n.strftime('%I').to_i).chop;sleep(60-n.sec) end}

Obrigado a QPaysTaxes pelas dicas

Cheddar v1.0.5, 162 bytes

O Cheddar não possui leitor de tempo / leitor de saída cmd, então eu tive que improvisar!

Golfe:

var f=->{IO.exec("time/t>c");(String::IO.read("c")).split(":")};var a=f()[0];for(;1;){var b=f();if(b[0]!=a){var c=Number::(a=b[0]);print("BONG "*c).head(5*c-1);}}

Ungolfed:

var f=->{
    IO.exec("time/t>c");
    (String::IO.read("c")).split(":")};
var a=f()[0];
for(;1;){
    var b=f();
    if(b[0]!=a){
        var c=Number::(a=b[0]);
        print("BONG "*c).head(5*c-1);
    }
}

Explicação:

Devido à biblioteca padrão limitada do Cheddar, tive que usar o cmd para gerar o tempo. Fiz isso salvando a saída de "time / t", que imprime a hora no formato de 12 horas, em um arquivo chamado "c". IO.read retorna um buffer que eu converti em uma string e dividi por ":", garantindo que a hora esteja sempre no índice zero. Salvei toda a operação em uma expressão lambda que me salvou 44 bytes. Depois desse ponto, entra na lógica de "se a hora armazenada não for igual à hora atual, defina a hora anterior como atual e imprima BONG n vezes, apare o espaço à direita".

O cheddar pode não ser a linguagem menos detalhada, mas pode ser divertido encontrar soluções alternativas como essa!

Infelizmente, esta é uma solução apenas para Windows.

Editar 1: salvou dois bytes substituindo "0 <1" na condição for para "1". Não esperava que 1 fosse avaliado como verdadeiro neste idioma!

Ruby, 82 81 bytes

loop{l=Time.new
puts ("BONG "*(l.hour%12+1)).chop if(l+1).hour!=l.hour
sleep 1}

A cada segundo, verificamos se é o último segundo da hora e o BONG em conformidade. Provavelmente poderia ser jogado mais com alguns truques sujos, mas não sei muitos. Também funciona de maneira diferente da outra resposta do Ruby.

Um byte economizado graças à cortesia de QPaysTaxes.

Python 2 , 105 106 bytes

import time
h=0
while 1:
 l=time.localtime();c=l[3]%12
 if l[4:6]==(0,0)and h!=c:print('BONG '*c)[:-1];h=c

Editar

Adicionado um byte alterando <para! = Após o feedback de @ pinkfloydx33. Bom lugar.

Testado o máximo possível localmente, mas não funciona no TIO, pois (obviamente) excede o limite de execução de 60 segundos. Por favor, sinta-se livre para testar localmente :-)

btw, perder esse espaço à direita me custou 7 bytes, caso contrário, isso teria sido inferior a 100.

Na ausência de TIO, aqui é emitido após aguardar uma hora. O programa foi iniciado às 15:27 com código de depuração extra para mostrar a hora da impressão (formato de 12 horas).

python bigben.py
time is 4:0:0
BONG BONG BONG BONG
time is 5:0:0
BONG BONG BONG BONG BONG

Bem simples, mas aqui está uma explicação para quem estiver interessado.

import time                 #Import the time module
h=0                         #Create a variable to store the hour that has just been printed
while 1:                    #Loop forever
 l=time.localtime()         #Get the local time from the time module
 c=l[3]%12                  #Set a variable to the current hour in 12 hour format
 if l[4:6]==(0,0)and h!=c:   #If minutes=0 and hours=0 and the last hour that was printed is not the current hour
  print "time is "+`c`+":"+`l[4]`+":"+`l[5]`    #Debug code to show hour
  print('BONG '*c)[:-1]     #Print 'BONG '*number of hours and lose the space from the end 
  h=c                       #Update the last hour that was printed

Python 3-100 97 92 bytes

from time import*
while 1:x=3600;sleep(x-time()%x);print(('BONG '*int(strftime("%I")))[:-1])[:-1])

Explicação:

import time;
while 1:
 t=time;x=3600;
 t.sleep(x-t.time()%x);#sleep for the remaining seconds until the next hour
 print(('BONG '*int(t.strftime("%I")))[:-1])#strftime("%")=nr of hours (1-12). Print the bongs and remove the last char

C, 238 bytes

#include<time.h>
#include<unistd.h>
i,j;f(){time_t t=time(0);struct tm l=*localtime(&t);for(;;){t=time(0),l=*localtime(&t),j=l.tm_hour;sleep(1);if(!(l.tm_min+l.tm_sec)){j=j%12?j<12?j:j-12:12;for(i=0;i<=j;i++)printf("BONG%c",i^j?32:10);}}}

Não tenho certeza se isso funciona corretamente, sou móvel e meu telefone não possui um compilador C. (Funciona apenas em sistemas tipo UNIX)

sh, 66 bytes

yes 'echo `yes BONG|sed $(date +%I)q`'|sh -s|awk '$0!=a&&a;{a=$0}'

Explicado

#Pipe a command into a subshell repeatedly
yes 'some command'|sh -s

#Print "hour" (1-12) worth of "BONG" strings, one per line,
#use backticks to merge them into a single space-separated string.
#(stolen from zeppelin's answer)
echo `yes BONG|sed $(date +%I)q`

#Print every time the output changes
awk '$0!=a&&a;{a=$0}

C, 198 bytes

#import<time.h>
h,i;f(){time_t t=time(0);struct tm l=*localtime(&t);for(h=l.tm_hour;;t=time(0),l=*localtime(&t))if(h-l.tm_hour%12){h=l.tm_hour%12;for(i=h?h%12:12;--i;)printf("BONG ");puts("BONG");}}

Javascript ES6 87 bytes

Edit: new Date/36e5%12|0||12Código @ETHProductions 'emprestado descaradamente para salvar 6 bytes

setInterval('Date().match`:00:00`?alert("BONG ".repeat(new Date/36e5%12|0||12)):5',1e3)

R, 104 105 bytes

f=format;repeat{Sys.sleep(1);q=Sys.time();if(f(q,"%M%S")=="0000")print(rep("BONG",as.double(f(q,"%I"))))}

A cada segundo, ele deve (deve) testar se estamos no final de uma hora e depois imprimir essa quantidade de BONGs.

JavaScript ES2015, 100 99 98 96 94 88 bytes

h=_=>new Date/36e5%12|0,p=h();for(;;)h()!=p&&(p=h(),alert('BONG '.repeat(p||12).trim()))

Explicação:

hé uma função que obtém a hora do dia com base em 12 horas usando o operador restante ( %12). 36e5é o número de milissegundos em uma hora usando a sintaxe exponencial para salvar caracteres. O newoperador não exige que parênteses sejam usados ​​com funções se não houver argumentos, portanto new Date. O JavaScript possui apenas aritmética de ponto flutuante, o| operador OR bit bit força o número a ser um número inteiro porque os operadores bit a bit JS trabalham com o subconjunto inteiro dos números representados pelo ponto flutuante IEEE 754.

A vírgula delineia subexpressões. pé inicializado para a hora atual ( p=h()).

for(;;) é usado para verificar repetidamente se algum BONG s deve ser alertado. A verificação é realizada tão rapidamente quanto o tempo de execução permitir.

Se a hora mudou ( h()!=p), atualizamos pe alertamos os BONG. O operador AND lógico é usado como uma proteção (se houver um curto-circuito h()===p) para determinar se os BONGs são emitidos.

String.prototype.repeaté novo no ES2015 e salva alguns caracteres usando algo como o ES5 Array.prototype.join.

hretorna zero para múltiplos exatos de 12 (ou seja, 12h, 12h), portanto, alteramos para 12 usando o OR lógico p||12.

Com agradecimentos a Kritixi Lithos e ETHProductions por idéias.

Excel VBA, 143 bytes

Saídas de código para a janela VBE Immediates

Sub b:Do:n=Now
If Minute(n)=0 Then:s="":For i=1To Hour(n) Mod 12:s=s &"BONG ":Next:Debug.?Trim(s):Application.Wait n+#0:1#:End If:Loop:End Sub

Versão divertida, 143 bytes (não-concorrente)

Embora seja bastante difícil fazer com que o excel entre no BONG, é bastante simples obter o excel para ir Beep. A Beepchamada produz um sinal sonoro, e o código abaixo o utiliza para produzir sinais sonoros indicando a hora, a hora, separada por pausas de 1 segundo.

Como acima, esse código faz com que o excel pareça não responder e :DoEventsé recomendável adicionar uma chamada ao final da primeira linha, pois melhora a experiência do usuário; no entanto, isso não é necessário para a execução correta do código.

Sub b:Set a=Application:Do:n=Now
If Minute(n)=0 Then:For i=1To Hour(n) Mod 12:Beep:a.Wait(Now+#0:0:1#):Next:a.Wait(n+#0:1#):End If:Loop:End Sub

Versão Ungolfed

Public Sub BigBen()
    Dim i As Byte
    Dim n As Date
    Dim w As Worksheet
    Dim a As Excel.Application
    Set a = Application
    Set w = a.ThisWorkbook.Sheets(1)
    Let w.Name = "Big Ben"

    Let w.[A1] = Now
    w.Columns("A:A").AutoFit

    Do
        DoEvents
        Let n = Now
        If Minute(n) = 0 Then

            ''  Print BONG
            Let s = ""
            For i = 1 To Hour(n) Mod 12 Step 1
                Let s = s & "BONG "
            Next i
            Debug.Print Trim(s)

            ''  Go Beep
            For i = 1 To Hour(n) Mod 12 Step 1
                Beep
                a.Wait (Now + #12:00:01 AM#) ''  <- #0:0:1# resolves to #12:00:01 AM#
            Next i

            ''  Keep Ticking After Going BONG
            While Now < n + #12:01:00 AM#    ''  <- #0:1# resolves to #12:01:00 AM#
                Let w.[A1] = Now
                Let a.StatusBar = IIf(Second(Now) Mod 2, "Tick", "Tock")
                DoEvents
            Wend
        End If

        ''  Tick Tock until its time to Go BONG again
        Let a.StatusBar = IIf(Second(n) Mod 2, "Tick", "Tock")
        Let w.[A1] = Now
    Loop

End Sub

C # 234 bytes

Não estou planejando ganhar nenhum prêmio aqui, mas uma implementação de C # é obrigatória.

using System;
using System.Linq;namespace B{class P{static void Main(){Func<int> h=()=>DateTime.Now.Hour % 12;var p=h();while (true){var t=h();if (t!=p)Console.WriteLine(string.Concat(Enumerable.Repeat("BONG",t== 0?12:t)));p=t;}}}}

Ungolfed com comentários:

using System;
using System.Linq;

namespace B
{
    class P
    {
        static void Main()
        {
            Func<int> h = () => DateTime.Now.Hour % 12; // h(): the hour in the range [0, 11], making this a lambda saves a few chars
            var p = h(); // p: Previous time
            while (true)
            {
                var t = h(); // t: Current time
                if (t != p) // If current hour is different to previous hour
                    Console.WriteLine(string.Concat(Enumerable.Repeat("BONG", t == 0 ? 12 : t))); // Print "BONG" t times (also correcting t = 0 to 12)
                p = t; // Current time is now previous time
            } // Repeat ad nauseum
        }
    }
}

Groovy, 72 bytes

{x={new Date().getHours()};y=x();while(1){if(y!=(y==x()){print "BONG "*y}}​}​​​

Quão?

Armazene um método para obter o horário atual.

x={new Date().getHours()};

Armazene as horas iniciais.

y=x();

Embora verdadeiro, se a hora atual não for igual à hora anterior, a hora atual de saída multiplicada por "BONG" para gerar a hora atual dos bongos.

while(1){if(y!=(y==x()){print "BONG "*y}}

+3 bytes %12para bongos não militares.

perl, 60 bytes

Atualizar

Substituído " "por$" , removido CORE::, contagem corrigida.

Golfe

say join$",(BONG)x(time/3600%12||12)while sleep -time%3600+1

Isso precisa ser executado com perl -E .

Observações

• Em perl, x while yé equivalente a while(y){x}(ondex está uma única instrução), mas não precisa dos colchetes. sleepé executado pela primeira vez antes de qualquer coisa ser impressa.
• timeusa UTC. O Big Ben original está no horário de verão (horário de verão britânico, BST) do final de março até o final de outubro.
• Um segundo é adicionado ao tempo de espera para garantir que o programa aguarde pelo menos um segundo. Isso significa que os BONGs sempre serão impressos com um segundo de atraso, o que é legal de acordo com as regras. Digamos que você esteja na ponte de Westminster, ca. A 300 m do Big Ben. No lado positivo, isso também significa que o programa imprimirá a quantidade correta de BONGs se for iniciado exatamente no início de uma hora (em vez de esperar 3600 segundos).
• sleepretorna o número de segundos esperados. Isso sempre será verdade.

QBIC , 82 bytes

X=$left$|(_d,2){Y=left$$|(_d,2)~Y<>X|x=!Y!%12~x=0|x=12]B=C[x|B=B+@BONG |]?_tB|]X=Y

Realmente precisa alterar o token para literais de código ( $) e implementar um recurso de substring ( left$(x,y)pode ser mais curto).

O funcionamento interno:

In the first part, we want to set X$ to the hour-component
of our system's time. The DATE is implemented in QBIC, but
Substring (LEFT$, RIGHT$ and MID$ in QBasic) is not (yet).
We need to use the QBasic LEFT$ function, and QBIC can do 
that using a 'code literal': everything from '$' to '|'
is not parsed by QBIC but passed on to QBasic.
X=               Set X$ to
$left$|(         the leftmost (note the '$' and '|' for the code literal)
_d,2)            2 characters of TIME$ (hh:mm format)
{                DO - infinite loop
Y=left$$|(_d,2)  Set Y$ in the same way
~Y<>X            If Y$ is not equal to X$ the hour has changed
|x=!Y!%12        THEN set x to the modulo 12 of Y$ cast to number
~x=0|x=12]       If Y% happens to be divisible by 12, set x to 12
B=C              Clear B$ (c$ never gets assiged a value)
[x|B=B+@BONG |]  For the given number of hours, add "BONG " to B$
?_tB|            Print B$, trim the trailing space
]                end if
X=Y              Update X$
<DO LOOP is implicitly closed>

Atualização (NC): $não é mais usada no conjunto de instruções QBICs, portanto agora pode ser usada livremente como código para QBasic sem a necessidade de literais de código. Nesse caso, ele salva 4 bytes, elevando o QBIC a 78 bytes:

X=left$(_d,2){Y=left$(_d,2)~Y<>X|x=!Y!%12~x=0|x=12]B=C[x|B=B+@BONG `]?_tB|]X=Y

SmileBASIC, 74 67 bytes

WAIT 61TMREAD OUT H,M,S?("BONG"+" BONG"*((H+11)MOD 12))*!(M+S)EXEC.

Produz grandes quantidades de quebras de linha "à direita";)

Editar: salvou 7 bytes com um melhor algoritmo de 24-> 12 horas.

PHP, 63 bytes

Eu poderia salvar mais dois bytes com o ASCII estendido. Mas atualmente estou com preguiça de fazer isso.

for(;;sleep(1))+date(is)?:print str_pad("
",5*date(h),"BONG ");

imprime os BONGs com uma quebra de linha líder precisamente a toda a hora. Corra com -nr.

C, 152

int a=0,i,L=25;main(){char s[9];for(i=-1;++i<48;){sprintf(s,"%02i:00:00",i);if(!strcmp(s,__TIME__)&&i!=L)a=L=i,i=-1;printf(a-->0?"BONG ":"\n");}main();}

Legível:

int a=0,i,L=25;

main(){
    char s[9];
    for(i=-1;++i<48;){
        sprintf(s,"%02i:00:00",i);
        if(!strcmp(s,__TIME__)&&i!=L)
            a=L=i,i=-1;
        printf(a-->0?"BONG ":"\n");
    }
    main();
}