Su tarea es crear un programa que imite al Big Ben (Twitter) .

Tarea

Cada vez que comienza una nueva hora (de acuerdo con la hora local de su computadora o UTC), debe generar tiempos BONGrepetidos hour(con un espacio entre las palabras). Por ejemplo, cuando son las 3 en punto, debe salir BONG BONG BONG. El formato de hora sigue el formato de 12 horas, es decir, después de las 12 en punto, tenemos 1 y no 13. El programa / función debe ejecutarse para siempre.

Ejemplo:

^{no envíe cosas dentro de los corchetes}

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

Reglas

• Cada serie de BONGs debe estar separada por una nueva línea
• Se permiten nuevas líneas iniciales / finales
• Sin embargo, los espacios iniciales / finales no están permitidos
• La presentación debe correr para siempre
• Su salida puede imprimirse ± 3 segundos desde el comienzo de la hora
• Es posible que no asuma el programa para ser ejecutado en cualquier hora específica

Este es el código de golf , por lo que gana el programa con el bytecount más corto.

05AB1E , 43 bytes

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

Pruébalo en línea! (jaja, esto no funcionará, expirará en 60 segundos. Descargue el intérprete 05AB1E para esto)

Explicación:

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  

¡Esto me llevó un tiempo al golf! Tal vez pueda jugar al golf un poco más, pero late *><>, así que es genial :)

Versión rápida:

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

Esperará un segundo al inicio y un segundo entre BONG

Golpetazo, 71, 70, 69 bytes

EDICIONES:

• Optimizó el cálculo del intervalo de reposo un bit, -1 byte;
• Se reemplazaron los backticks con xargs, -1 byte (¡Gracias @ jrtc27!).

Golfed

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

Versión de prueba

Funciona con minutos en lugar 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

Pruébalo aquí! ( o esta versión que lo hace cada minuto para probar )

Esto genera una cantidad de BONGs separados por espacios en función de qué hora es (y 13 es 1, etc.). No hay espacio final después de la final BONG, y hay una nueva línea final.

Técnicamente esto no funciona para siempre (pero básicamente lo hace). Fugas ~ 28 bytes por día (ignorando la sobrecarga del intérprete ...). Tardaría unos 105062 años en perder 1GiB.

Aproximándose para la sobrecarga del intérprete, la pila es solo una porción de float64s en el intérprete de Golang. Así que simplemente hice 28*8224 bytes por día. Dividí este número por el número de bytes en un gibibyte (1073741824) y luego 365 para aproximar que tomaría 13132.85 años perder 1 GiB.

Nota sobre los intérpretes.

El intérprete en línea está en Javascript. La página debe estar abierta y visible para que pueda verificar la hora actual y generar los BONG. El intérprete de Golang no tiene esa limitación.

Explicación

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)

Esto usa la hora UTC (que se alinea con la cosa real). Debido a la naturaleza no comprobable del código, puede intentar lo siguiente, que hace lo mismo, pero cada 60 segundos:

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

f()

Aquí hay una versión adicional de 99 bytes que utiliza la 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

¡Gracias a @ Flp.Tkc por guardar 5 bytes!

¡Gracias a @BenAston por guardar 2 bytes más!

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

Dado que el archivo se ejecuta como un bucle infinito, comienzo con un retraso de 1 s, ya que necesito uno de todos modos después de los bongs, y esto ahorra ciclos de CPU. El >nulse coloca con cuidado para guardar un byte ( 1>nulcausaría que el 1 fuera comido por la redirección). Luego hacemos un bucle hasta que los minutos y segundos sean cero. Los bongs se construyen tomando el módulo de hora negativa 12 y solicitando los últimos hcaracteres de una cadena de 12 caracteres. Cuando hes cero, esto realmente nos da la cadena completa, por lo tanto, 12 bongs. Entonces es suficiente reemplazar los caracteres con la palabra BONG. Cuando se ejecuta, se ve así (tenga en cuenta que la imagen no se repite, por lo que deberá volver a cargarla para ver la animación nuevamente):

Bash + Linux crontab, 90

Esperaba que esto fuera más corto que las otras respuestas de shell. Aún así, creo que es un enfoque interesante:

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

El script se ejecuta una vez, llena el crontab y luego sale. Sin embargo, la salida de los cronjobs se envía al terminal desde el que se ejecutó el script. Creo que esto satisface el requisito de presentación debe ejecutarse para siempre .

Advertencia : esto borrará todas las entradas crontab existentes, así que asegúrese de tener una copia de seguridad de las existentes.

Esto funciona en Ubuntu 16.04, que usa Vixie cron por defecto.

Rubí, 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}

Versión antigua

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

Gracias a QPaysTaxes por los consejos

Cheddar v1.0.5, 162 bytes

Cheddar no tiene un lector de tiempo incorporado / lector de salida cmd, ¡así que tuve que improvisar!

Golfizado:

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

Sin golf:

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

Explicación:

Debido a la biblioteca estándar limitada de Cheddar, tuve que usar cmd para generar el tiempo. Lo hice guardando la salida de "hora / t", que imprime la hora en formato de 12 horas, en un archivo llamado "c". IO.read devuelve un búfer que fundí en una cadena y se dividió por ":" que aseguró que la hora siempre esté en el índice cero. Guardé toda esa operación en una expresión lambda que me salvó 44 bytes. Después de ese punto, entra en la lógica de "si la hora almacenada no es igual a la hora actual, configure la hora anterior como actual e imprima BONG n veces, recorte el espacio final".

Cheddar puede no ser el lenguaje menos detallado, ¡pero puede ser divertido encontrar soluciones como esta!

Lamentablemente, esta es una solución solo para Windows.

Edición 1: se guardaron dos bytes reemplazando "0 <1" en la condición for por "1". ¡No esperaba que 1 se evaluara como verdadero en este idioma!

Ruby, 82 81 bytes

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

Cada segundo verificamos si es el último segundo de la hora, y BONG en consecuencia. Probablemente podría jugar más golf con algunos trucos sucios, pero no sé muchos. También funciona de manera diferente a la otra respuesta de Ruby.

Un byte guardado gracias a la cortesía 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

Se agregó un byte cambiando <a! = Después de los comentarios de @ pinkfloydx33. Buen lugar.

Probado tanto como sea posible localmente pero no funciona en TIO ya que (obviamente) excede el límite de ejecución de 60 segundos. Por favor, siéntase libre de probar localmente :-)

por cierto, perder ese molesto espacio final me costó 7 bytes; de lo contrario, esto habría sido inferior a 100.

En ausencia de TIO aquí se emite después de esperar una hora. El programa se inició a las 15:27 con un código de depuración adicional para mostrar la hora de la impresión (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

Bastante sencillo, pero aquí hay una explicación para cualquiera que esté interesado.

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

Explicación:

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

No estoy seguro de si esto funciona correctamente, y soy móvil, y mi teléfono no tiene un compilador de C. (Solo funciona en sistemas similares a 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

Editar: El new Date/36e5%12|0||12código de @ETHProductions tomó prestado descaradamente para guardar 6 bytes

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

R, 104105 bytes

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

Cada segundo, (debería) probar si estamos al final de una hora, luego imprimir esa cantidad 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()))

Explicación:

hes una función que obtiene la hora del día basada en 12 horas utilizando el operador restante ( %12). 36e5es el número de milisegundos en una hora que usa la sintaxis exponencial para guardar caracteres. El newoperador no requiere que se usen paréntesis con funciones si no hay argumentos, por lo tanto new Date. JavaScript solo tiene aritmética de coma flotante, la| operador OR a nivel de bit obliga al número a ser un número entero porque los operadores JS a nivel de bit trabajan con el subconjunto entero de los números representados por el punto flotante IEEE 754.

La coma delinea subexpresiones. pse inicializa a la hora actual ( p=h()).

for(;;) se usa para verificar repetidamente si alguno BONG debe alertar a . La verificación se realiza tan rápido como lo permita el tiempo de ejecución.

Si la hora ha cambiado ( h()!=p), entonces actualizamos p y luego alertamos al BONGs. El operador lógico AND se usa como protección (cortocircuita si h()===p) para determinar si los BONGs se emiten.

String.prototype.repeates nuevo en ES2015 y ahorra algunos caracteres al usar algo como ES5 Array.prototype.join.

hdevuelve cero para múltiplos exactos de 12 (es decir, 12 p.m., 12 a.m.), por lo que lo cambiamos a 12 utilizando el OR lógico p||12.

Gracias a Kritixi Lithos y ETHProductions por sus ideas.

Excel VBA, 143 bytes

Salidas de código a la ventana Inmediatos de VBE

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

Versión divertida, 143 bytes (no competitiva)

Si bien sería bastante difícil lograr que Excel sobresaliera en BONG, es bastante sencillo lograr que sobresalga Beep. La Beepllamada produce un pitido, y el código siguiente lo utiliza para producir pitidos que indican la hora, en la hora, separados por pausas de 1 segundo.

Al igual que con lo anterior, este código hace que Excel parezca que no responde y :DoEventsse recomienda agregar una llamada al final de la primera línea, ya que mejora la experiencia del usuario, sin embargo, esto no es necesario para la ejecución correcta del 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

Versión sin golf

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

No planeo ganar ningún premio aquí, pero una implementación de C # es obligatoria.

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 comentarios:

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}}​}​​​

¿Cómo?

Almacene un método para obtener las horas actuales.

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

Almacenar horas iniciales.

y=x();

Si bien es cierto, si la hora actual no es igual a la hora anterior, la hora actual de salida se multiplica por "BONG" para generar la hora actual de bongs.

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

+3 bytes %12para bongs no militares.

perl, 60 bytes

Actualizar

Reemplazado " "con $", eliminadoCORE:: , recuento corregido.

Golf

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

Esto debe ejecutarse con perl -E .

Observaciones

• En perl, x while yes equivalente a while(y){x}(donde xes una sola declaración) pero no necesita los corchetes.sleepse ejecuta la primera vez antes de que se imprima algo.
• timeusa UTC. El Big Ben original está en horario de verano (British Summer Time, BST) desde finales de marzo hasta finales de octubre.
• Se agrega un segundo al tiempo de espera para garantizar que el programa espere al menos un segundo. Esto significa que los BONG siempre se imprimirán un segundo tarde, lo cual es legal según las reglas. Digamos que estás parado en el puente de Westminster, ca. A 300 m del Big Ben. En el lado positivo, esto también significa que el programa imprimirá la cantidad correcta de BONG si se inicia exactamente al comienzo de una hora (en lugar de esperar 3600 segundos).
• sleepdevuelve el número de segundos esperados. Esto siempre será cierto.

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 necesito cambiar el token para los literales de código ( $) e implementar una función de subcadena ( left$(x,y)puede ser más corta).

El funcionamiento 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>

Actualización (NC): $ya no se usa en el conjunto de instrucciones de QBIC, por lo que ahora se puede usar libremente como código para QBasic sin la necesidad de literales de código. En este caso, ahorra 4 bytes, llevando 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.

Produce grandes cantidades de saltos de línea "finales";)

Editar: guardado 7 bytes con un mejor algoritmo de 24-> 12 horas.

PHP, 63 bytes

Podría guardar dos bytes más con ASCII extendido. Pero actualmente soy demasiado vago para eso.

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

imprime los BONG con un salto de línea líder precisamente a la hora completa. Corre 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();}

Legible:

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