Il tuo compito è creare un programma che imiti il Big Ben (Twitter) .

Compito

Ogni volta che è iniziata una nuova ora (in base all'ora locale del computer o all'ora UTC), è necessario emettere tempi BONGripetuti hour(con uno spazio tra le parole). Ad esempio, quando sono le 3, devi emettere BONG BONG BONG. Il formato dell'ora segue il formato dell'ora di 12 ore, ovvero dopo le 12 abbiamo 1 e non 13. Il programma / funzione deve essere eseguito per sempre.

Esempio:

^{non produrre materiale all'interno delle parentesi}

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

Regole

• Ogni serie di BONGs deve essere separata da una nuova riga
• Sono consentite nuove linee guida / finali
• Tuttavia , non sono consentiti spazi iniziali / finali
• L'invio deve essere eseguito per sempre
• L'output può essere stampato ± 3 secondi dall'inizio dell'ora
• Si può non assumere il programma deve essere eseguito in qualsiasi ora specifica

Questo è code-golf , quindi vince il programma con il byte più breve!

05AB1E , 43 byte

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

Provalo online! (lol questo non funzionerà, andrà in timeout in 60 secondi. Scarica l' interprete 05AB1E per questo)

Spiegazione:

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  

Mi ci è voluto del tempo per giocare a golf! Potrei essere in grado di giocare a golf un po 'di più, ma batte *><>, quindi è bello :)

Versione veloce:

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

Aspetterà un secondo all'avvio e un secondo tra i BONG

bash, 71, 70, 69 byte

Modifiche:

• Ottimizzato il calcolo dell'intervallo di sospensione un po ', -1 byte;
• Sostituiti i backtick con xargs, -1 byte (grazie @ jrtc27!).

golfed

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

spiegato

#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

Versione di prova

Funziona con minuti anziché ore

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

*> <> , 48 47 44 byte

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

Provalo qui! ( o questa versione che lo fa ogni minuto per i test )

Ciò genera un numero di BONGs separati da spazi in base all'ora (e 13 è 1, ecc.). Non ci sono spazi finali dopo la finale BONGe c'è una nuova riga finale.

Tecnicamente questo non funziona per sempre (ma sostanzialmente lo fa). Perdono ~ 28 byte al giorno (ignorando il sovraccarico dell'interprete ...). Ci vorranno ~ 105062 anni per perdere 1GiB.

Approssimando al sovraccarico dell'interprete, la pila è solo una fetta di float64s sull'interprete Golang. Quindi ho semplicemente 28*8creato 224 byte al giorno. Ho diviso questo numero per il numero di byte in un gibibyte (1073741824), quindi 365 per approssimare che ci sarebbero voluti 13132,85 anni per perdere 1 GiB.

Nota sugli interpreti

L'interprete online è in Javascript. La pagina deve essere aperta e visibile per poter controllare l'ora che è attualmente e produrre i BONG. L' interprete Golang non ha questa limitazione.

Spiegazione

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 byte

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

Questo utilizza l'ora UTC (che si allinea con la cosa reale). A causa della natura non verificabile del codice, puoi provare quanto segue che fa la stessa cosa, ma ogni 60 secondi:

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

f()

Ecco una versione bonus di 99 byte che utilizza l'ora locale:

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

JavaScript (ES6), 125 123 117 115 byte

Grazie a @ Flp.Tkc per aver salvato 5 byte!

Grazie a @BenAston per aver salvato altri 2 byte!

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

Snippet di snack

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

Lotto, 142 byte

@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

Poiché il file viene eseguito come un ciclo infinito, inizio con un ritardo di 1 secondo, poiché ne ho bisogno comunque dopo i bong, e questo fa risparmiare cicli di CPU. Il >nulè posizionata accuratamente per salvare un byte ( 1>nulcauserebbe l'1 per essere mangiato dal reindirizzamento). Quindi eseguiamo il loop fino a quando sia i minuti che i secondi sono zero. I bong sono costruiti prendendo l'ora negativa modulo 12 e chiedendo gli ultimi hcaratteri da una stringa di 12 caratteri. Quando hè zero, questo in realtà ci dà l'intera stringa, quindi 12 bong. È quindi sufficiente sostituire i caratteri con la parola BONG. Quando eseguito sembra qualcosa del genere (si noti che l'immagine non esegue il loop, quindi sarà necessario ricaricare forzatamente per vedere di nuovo l'animazione):

Bash + Linux crontab, 90

Speravo che questo fosse più breve delle altre risposte della shell. Tuttavia, penso che sia un approccio interessante:

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

Lo script viene eseguito una volta, popola il crontab, quindi esce. Tuttavia, l'output di cronjobs viene inviato al terminale da cui è stato eseguito lo script. Penso che questo soddisfi la richiesta deve essere eseguita per sempre .

Attenzione : questo cancellerà tutte le voci crontab esistenti, quindi assicurati di averne eseguito il backup.

Funziona su Ubuntu 16.04, che utilizza Vixie cron per impostazione predefinita.

Rubino, 112 99 byte

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

Vecchia versione

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

Grazie a QPaysTaxes per i suggerimenti

Cheddar v1.0.5, 162 byte

Cheddar non ha un lettore di tempo / lettore di output cmd incorporato, quindi ho dovuto improvvisare!

golfed:

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);
    }
}

Spiegazione:

A causa della libreria standard limitata di Cheddar, ho dovuto usare cmd per generare il tempo. L'ho fatto salvando l'output di "time / t", che stampa l'ora in formato 12 ore, in un file chiamato "c". IO.read restituisce un buffer che ho inserito in una stringa e diviso per ":" che ha assicurato che l'ora è sempre nell'indice zero. Ho salvato l'intera operazione in un'espressione lambda che mi ha salvato 44 byte. Dopo quel punto entra nella logica di "se l'ora memorizzata non è uguale all'ora corrente, imposta l'ora precedente su corrente e stampa BONG n volte, taglia lo spazio finale".

Cheddar potrebbe non essere la lingua meno dettagliata ma può essere divertente trovare soluzioni alternative come questa!

Purtroppo questa è una soluzione solo per Windows.

Modifica 1: salvato due byte sostituendo "0 <1" nella condizione for con "1" Non mi aspettavo che 1 valesse come vero in questa lingua!

Rubino, 82 81 byte

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

Ogni secondo controlliamo se è l'ultimo secondo dell'ora e di conseguenza BONG. Probabilmente potrebbe essere ulteriormente giocato a golf con alcuni trucchi sporchi, ma non ne conosco troppi. Inoltre funziona diversamente dall'altra risposta di Ruby.

Un byte salvato grazie alla cortesia di QPaysTaxes.

Python 2 , 105 106 byte

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

modificare

Aggiunto un byte modificando <in! = Dopo il feedback di @ pinkfloydx33. Buon posto.

Testato il più possibile localmente ma non funziona su TIO in quanto (ovviamente) supera il limite di esecuzione di 60 secondi. Non esitate a testare localmente :-)

tra l'altro, perdere quel fastidioso spazio di trascinamento mi è costato 7 byte, altrimenti sarebbe stato inferiore a 100.

In assenza di TIO qui viene emesso dopo aver atteso un'ora. Prog è stato avviato alle 15:27 con un codice di debug aggiuntivo per mostrare l'ora della stampa (formato 12 ore).

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

Abbastanza semplice, ma ecco una spiegazione per chiunque sia interessato.

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 byte

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

Spiegazione:

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 byte

#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);}}}

Non sono sicuro che funzioni correttamente e sono mobile e il mio telefono non ha un compilatore C. (Funziona solo su sistemi simili a UNIX)

sh, 66 byte

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

spiegato

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

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

Modifica: il new Date/36e5%12|0||12codice @ETHProductions preso in prestito senza vergogna per salvare 6 byte

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

R, 104 105 byte

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

Ogni secondo, dovrebbe (dovrebbe) verificare se siamo alla fine di un'ora, quindi stampare quella quantità di BONGs.

JavaScript ES2015, 100 99 98 96 94 88 byte

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

Spiegazione:

hè una funzione che ottiene l'ora del giorno in base a 12 ore utilizzando l'operatore restante ( %12). 36e5è il numero di millisecondi in un'ora che utilizza la sintassi esponenziale per salvare i caratteri. L' newoperatore non richiede che le parentesi vengano utilizzate con le funzioni se non ci sono argomenti, quindi new Date. JavaScript ha solo l'aritmetica in virgola mobile, l' |operatore OR bit a bit impone che il numero sia un numero intero poiché gli operatori bit a bit JS lavorano con il sottoinsieme intero dei numeri rappresentati da IEEE 754 in virgola mobile.

La virgola delinea le sottoespressioni. pè inizializzato sull'ora corrente ( p=h()).

for(;;)viene utilizzato per verificare ripetutamente se BONGè necessario avvisare di eventuali messaggi di posta elettronica. Il controllo viene eseguito con la stessa rapidità consentita dal runtime.

Se l'ora è cambiata ( h()!=p), quindi aggiorniamo p e quindi avvisiamo la BONGs. L'operatore logico AND viene utilizzato come protezione (cortocircuita se h()===p) per determinare se gli BONGs vengono emessi.

String.prototype.repeatè nuovo in ES2015 e salva alcuni personaggi usando qualcosa come ES5 Array.prototype.join.

hrestituisce zero per multipli esatti di 12 (ovvero 12pm, 12am), quindi lo cambiamo in 12 utilizzando l'OR logico p||12.

Grazie a Kritixi Lithos e ETHProductions per idee.

Excel VBA, 143 byte

L'output del codice nella finestra 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

Versione divertente, 143 byte (non competitiva)

Mentre sarebbe piuttosto difficile ottenere Excel per andare BONG, è piuttosto semplice ottenere Excel per andare Beep. La Beepchiamata emette un segnale acustico e il codice seguente lo utilizza per produrre segnali acustici che indicano l'ora, l'ora, separata da pause di 1 secondo.

Come sopra, questo codice fa apparire excel non rispondente e si consiglia di aggiungere una :DoEventschiamata alla fine della prima linea poiché migliora l'esperienza dell'utente, tuttavia ciò non è necessario per la corretta esecuzione del codice.

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

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

Non ho intenzione di vincere alcun premio qui, ma un'implementazione in C # è obbligatoria.

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 con commenti:

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 byte

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

Come?

Memorizza un metodo per ottenere le ore correnti.

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

Conservare le ore iniziali.

y=x();

Se vero, se l'ora corrente non è uguale all'ora precedente, l'ora corrente di uscita moltiplicata per "BONG" per emettere l'ora corrente di bong.

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

+3 byte %12per i bong non militari.

perl, 60 byte

Aggiornare

Sostituito " "con $", rimosso CORE::, conteggio corretto.

Golf

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

Questo deve essere eseguito con perl -E.

Osservazioni

• In perl, x while yequivale a while(y){x}(dove xè una singola istruzione) ma non ha bisogno delle parentesi. sleepviene eseguito la prima volta prima di stampare qualsiasi cosa.
• timeusa UTC. Il Big Ben originale è in estate (British Summer Time, BST) da fine marzo a fine ottobre.
• Un secondo viene aggiunto al tempo di attesa per garantire che il programma attenda almeno un secondo. Ciò significa che i BONG verranno sempre stampati con un secondo di ritardo, il che è legale secondo le regole. Supponiamo che ti trovi sul ponte di Westminster, ca. 300 m di distanza dal Big Ben. Tra i lati positivi, ciò significa anche che il programma stamperà la quantità corretta di BONG se viene avviato esattamente all'inizio di un'ora (invece di attendere 3600 secondi).
• sleeprestituisce il numero di secondi attesi. Questo sarà sempre vero.

QBIC , 82 byte

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

Devo davvero cambiare il token per i letterali di codice ( $) e implementare una funzione di sottostringa ( left$(x,y)può essere più breve).

I meccanismi interni:

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>

Aggiornamento (NC): $non viene più utilizzato nel set di istruzioni QBIC, quindi ora può essere utilizzato liberamente come codice per QBasic senza la necessità di letterali di codice. In questo caso, salva 4 byte, portando QBIC a 78 byte:

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 byte

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

Produce grandi quantità di interruzioni di riga "finali";)

Modifica: salvato 7 byte con un algoritmo 24-> 12 ore migliore.

PHP, 63 byte

Potrei salvare altri due byte con ASCII esteso. Ma al momento sono troppo pigro per quello.

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

stampa i BONG con un'interruzione di linea leader proprio nell'ora intera. Corri con -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();}

Leggibile:

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