您的任务是创建一个模仿Big Ben（Twitter）的程序。

任务

每当新的一小时开始时（根据计算机的本地时间或UTC），您都必须输出BONG重复的hour时间（单词之间留一个空格）。例如，当是3点钟时，您必须输出BONG BONG BONG。时间格式遵循12小时制，即12点以后，我们是1，而不是13。程序/功能必须永远运行。

例：

^{不要在括号内输出内容}

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

规则

• 的每个序列BONG必须用换行符分隔
• 允许前导/尾随换行符
• 然而前导/尾随空格都不会允许
• 提交必须永远运行
• 您的输出可能会从小时开始时起打印±3秒
• 您可能不假定该程序在任何特定时间运行

这是代码高尔夫球，因此字节数最短的程序将获胜！

05AB1E，43个字节

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

在线尝试！（大声笑这将不起作用，它将在60秒后超时。为此下载05AB1E解释器）

说明：

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  

这花了我一段时间去打高尔夫球！我也许可以再打一点高尔夫球，但是拍子打起来*><>，所以很酷:)

快速版本：

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

在启动时将等待一秒钟，在BONG之间等待一秒钟

重击 71， 70，69字节

编辑：

• 优化了睡眠间隔的计算，为-1个字节；
• 用-1个字节的xargs替换了反引号（感谢@ jrtc27！）。

打高尔夫球

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

讲解

#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

测试版本

使用分钟而不是小时

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

*> <>，48 47 44字节

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

在这里尝试！（或此版本每分钟都会进行测试）

这BONG将根据小时数（且13是1，依此类推）输出用空格分隔的s 数。final之后没有尾随空格BONG，并且尾随换行符。

从技术上讲，这不会永远运行（但基本上会运行）。每天泄漏约28个字节（忽略解释器开销...）。泄漏1GiB大约需要105062年。

float64近似于解释器的开销，堆栈只是Golang解释器上s的一部分。所以我干脆28*8每天要拿出224个字节。我将此数字除以一个千兆字节（1073741824）中的字节数，然后除以365，得出泄漏1 GiB大约需要13132.85年。

关于口译员的注意事项

在线解释器使用Javascript。该页面必须打开并且可见，以便检查当前时间并输出提示音。该Golang解释有没有这样的限制。

说明

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字节

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

这使用UTC时间（与实际时间一致）。由于代码的不可测试性，您可以尝试执行以下操作，但是每60秒执行一次：

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

f()

这是一个使用本地时间的额外的99字节版本：

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

的JavaScript（ES6），125个 123 117 115字节

感谢@ Flp.Tkc节省了5个字节！

感谢@BenAston节省了2个字节！

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

零食片段

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

批处理，142字节

@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

由于文件是无限循环运行的，因此我以1s的延迟开始，因为在发出“ bong”之后仍然需要一个，因此节省了CPU周期。将>nul被小心地定位，以节省一个字节（1>nul将导致1至通过重定向被吃掉）。然后我们循环直到分钟和秒都为零。通过采用负小时模12并h从12个字符的字符串中索取最后一个字符来构造烟枪。当h为零时，这实际上为我们提供了整个弦，因此为12响。然后用单词替换字符就足够了BONG。运行时，它看起来像这样（请注意，图像不会循环播放，因此您需要强制重新加载才能再次看到动画）：

Bash + Linux crontab，90

我希望它比其他shell回答要短。不过，我认为这是一种有趣的方法：

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

该脚本运行一次，填充crontab，然后退出。但是，cronjobs的输出将发送到运行脚本的终端。我认为这满足提交必须永远运行的要求。

警告 -这会清除所有现有的crontab条目，因此请确保已备份现有的crontab条目。

这适用于Ubuntu 16.04，默认情况下使用的是Vixie cron。

Ruby，112 99字节

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

旧版本

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

感谢QPaysTaxes的提示

Cheddar v1.0.5，162个字节

切达（Cheddar）没有内置的时间读取器/ cmd输出读取器，因此我不得不即兴创作！

打高尔夫球：

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

取消高尔夫：

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

说明：

由于Cheddar的标准库有限，我不得不使用cmd来生成时间。为此，我将“ time / t”的输出保存到名为“ c”的文件中，该输出以12小时格式打印时间。IO.read返回一个缓冲区，我将其强制转换为字符串并用“：”分隔，以确保小时始终处于索引零。我将整个操作保存到一个lambda表达式中，该表达式节省了44个字节。在那之后，它变成了“如果存储的小时数不等于当前的小时数，将前一个小时数设置为当前时间并打印BONG n次，修剪尾随空格”的逻辑。

Cheddar可能不是最冗长的语言，但是找到这样的变通办法可能会很有趣！

遗憾的是，这是仅Windows的解决方案。

编辑1：通过将for-condition中的“ 0 <1”替换为“ 1”，保存了两个字节，我没想到1在这种语言中的求值结果为true！

Ruby，82 81个字节

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

我们每秒检查一次是否是小时的最后一秒，然后相应地BONG。也许可以通过一些肮脏的技巧进一步打高尔夫球，但是我不知道太多。而且它的工作原理与其他Ruby答案不同。

借助QPaysTaxes节省了一个字节。

Python 2中，105个 106字节

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

编辑

@ pinkfloydx33反馈后，通过将<更改为！=来增加一个字节。好地方。

在本地进行了尽可能多的测试，但不适用于TIO，因为它（显然）超过了60秒的执行限制。请随时在本地进行测试:-)

顺便说一句，丢失那个令人讨厌的尾随空间花了我7个字节，否则它将低于100。

在没有TIO的情况下，等待一个小时后将在此处输出。Prog在15:27开始，带有额外的调试代码来显示打印时间（12小时格式）。

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

非常简单，但是这里是对任何感兴趣的人的解释。

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字节

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

说明：

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字节

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

我不确定这是否可以正常工作，并且我可以移动，并且我的手机没有C编译器。（仅适用于类似UNIX的系统）

sh，66个字节

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

讲解

#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字节

#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字节

编辑：无耻地借用@ETHProductions' new Date/36e5%12|0||12代码以保存6个字节

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

R，104个 105字节

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

每秒，它将（应该）测试我们是否在一小时结束时，然后打印该数量的BONGs。

的JavaScript ES2015，100个 99 98 96 94 88字节

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

说明：

h是使用余数运算符（%12）获取一天中基于12小时的小时的函数。36e5是使用指数语法保存字符的一小时内的毫秒数。该new运营商不要求括号与功能的使用，如果没有参数，因此new Date。JavaScript仅具有浮点算法，|按位OR运算符可将数字强制为整数，因为JS的按位运算符可使用IEEE 754浮点表示的数字的整数子集。

逗号描述子表达式。p初始化为当前小时（p=h()）。

for(;;)用于反复检查是否BONG应发出任何警报。检查将以运行时允许的最快速度执行。

如果小时已更改（h()!=p），则我们更新p，然后提醒BONGs。逻辑AND运算符用作保护（如果短路，则h()===p确定是否BONG输出s）。

String.prototype.repeat是ES2015的新增功能，可以节省使用ES5之类的字符Array.prototype.join。

h对于12的精确倍数（即12 pm、12am）返回零，因此我们使用逻辑OR将其更改为12 p||12。

感谢Kritixi Lithos和ETHProductions的想法。

Excel VBA，143字节

代码输出到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

趣味版，143字节（非竞争）

虽然让excel变得非常困难，但是让excel变得非常简单Beep。的Beep呼叫产生一个嘟嘟声，并且下面使用其来产生蜂鸣声，指示一小时的代码，在小时，1秒的暂停分隔开。

与上面一样，此代码使excel显得无响应，并:DoEvents建议在第一行末尾添加一个调用，因为它可以改善用户体验，但是，对于正确执行代码而言，这不是必需的。

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

非高尔夫版本

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个字节

我不打算在这里赢得任何奖项，但是必须实施C＃。

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

取消评论：

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个字节

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

怎么样？

存储获取当前时间的方法。

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

存放最初的时间。

y=x();

当为true时，如果当前小时不等于前一个小时，则输出当前小时乘以“ BONG”，以输出当前的邦斯小时。

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

+3字节%12用于非军事打击。

perl，60个字节

更新资料

替换 " "为$"，已移除CORE::，更正了计数。

高尔夫球

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

这需要与运行perl -E。

备注

• 在perl中，x while y等价于while(y){x}（其中x是单个语句），但不需要括号。sleep在打印任何内容之前第一次执行。
• time使用UTC。原始的大笨钟在3月底到10月底的夏季时间（英国夏令时，BST）。
• 等待时间增加一秒钟，以确保程序等待至少一秒钟。这意味着，BONG总是会延迟一秒钟打印，这是根据规则是合法的。假设您正站在威斯敏斯特桥上。距大本钟300 m。从好的方面来说，这也意味着如果程序恰好在一小时的开始（而不是等待3600秒）启动，则它将打印正确数量的BONG。
• sleep返回等待的秒数。这将永远是正确的。

QBIC，82字节

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

确实需要更改代码文字（$）的标记并实现子字符串功能（left$(x,y)可以更短）。

内部工作原理：

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>

更新（NC）：$在QBIC指令集中不再使用，因此现在可以将其自由地用作QBasic的代码，而无需代码文字。在这种情况下，它将节省4个字节，从而使QBIC达到78个字节：

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字节

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

输出大量的“尾随”换行符；）

编辑：使用更好的24-> 12小时算法保存了7个字节。

PHP，63字节

我可以再使用扩展的ASCII保存两个字节。但是我目前对此太懒了。

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

在整整一个小时内以领先的换行符打印BONG。用运行-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();}

可读性：

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