당신의 임무는 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)

규칙

• BONGs의 각 시리즈 는 개행으로 분리되어야합니다.
• 선행 / 트레일 링 개행이 허용됩니다
• 그러나 앞 / 뒤 공간 은 허용 되지 않습니다
• 제출은 영원히 실행되어야합니다
• 출력은 시간 시작부터 ± 3 초 인쇄 될 수 있습니다
• 특정 시간에 프로그램이 실행된다고 가정 할 수 없습니다

이것은 code-golf 이므로 가장 짧은 바이트 수를 가진 프로그램이 승리합니다!

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]

시작시 1 초, BONG 사이에서 1 초간 기다립니다.

세게 때리다, 71, 70, 69 바이트

EDITS :

• 수면 간격 계산을 비트 -1 바이트로 최적화했습니다.
• 백틱을 xargs, -1 바이트로 대체했습니다 (감사합니다 @ 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시간인지를 기준으로 여러 s를 공백으로 구분하여 출력합니다 (13은 1 등). final 뒤에 후행 공백이 없으며 BONG후행 줄 바꿈이 있습니다.

기술적으로 이것은 영원히 실행되지는 않지만 기본적으로 작동합니다. 하루에 ~ 28 바이트가 누출됩니다 (인터프리터 오버 헤드 무시 ...). 1GiB가 누출되는 데 ~ 105062 년이 소요됩니다.

인터프리터 오버 헤드를 고려하면 스택은 float64Golang 인터프리터 에서 s 조각 일뿐입니다. 그래서 나는 28*8하루에 224 바이트를 생각해 냈습니다. 이 숫자를 1 기가 바이트를 유출하는 데 13132.85 년이 걸리는 것으로 추정하기 위해이 수를 1 기가 바이트 (1073741824)의 바이트 수로 나눈 다음 365로 나눕니다.

통역사 참고 사항

온라인 통역사는 Javascript로되어 있습니다. 현재 시간을 확인하고 BONG을 출력하려면 페이지를 열어서 볼 수 있어야합니다. 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

자바 스크립트 (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)

자바 스크립트 (ES6) 125 123 117 115 바이트

5 바이트를 절약 한 @ Flp.Tkc에게 감사합니다!

2 바이트를 더 절약 한 @BenAston에게 감사합니다!

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

파일이 무한 루프로 실행되기 때문에, 봉 이후에 필요할 때마다 1 초 지연으로 시작하여 CPU주기를 절약합니다. 는 >nul(바이트를 저장 신중히 위치 1>nul1을 야기 리디렉션하여 먹을 수). 그런 다음 분과 초가 모두 0이 될 때까지 반복합니다. 봉은 음수 시간 모듈로 12를 취하여 12 h자 문자열에서 마지막 문자를 요청하여 구성됩니다 . h0 일 때는 실제로 전체 줄을 제공하므로 12 개의 봉입니다. 그런 다음 문자를 단어로 바꾸면됩니다 BONG. 실행하면 다음과 같이 보입니다 (이미지가 반복되지 않으므로 애니메이션을 다시 보려면 강제로 다시로드해야합니다).

배쉬 + 리눅스 크론 탭, 90

나는 이것이 다른 쉘 답변보다 짧기를 바랐다. 여전히 흥미로운 접근법이라고 생각합니다.

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

스크립트가 한 번 실행되고 crontab을 채우고 종료됩니다. 그러나 cronjobs의 출력은 스크립트가 실행 된 터미널로 전송됩니다. 제출 이 영원히 요구 사항을 충족 해야 한다고 생각 합니다 .

경고 -기존 크론 탭 항목이 지워 지므로 기존 항목이 백업되어 있는지 확인하십시오.

이것은 기본적으로 Vixie cron 를 사용하는 Ubuntu 16.04에서 작동합니다 .

루비, 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에 감사합니다

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

설명:

체다의 제한된 표준 라이브러리로 인해 시간을 생성하기 위해 cmd를 사용해야했습니다. 12 시간 형식으로 시간을 인쇄하는 "time / t"의 출력을 "c"라는 파일에 저장하여이 작업을 수행했습니다. IO.read는 문자열을 캐스팅하고 ":"로 나누는 버퍼를 반환하여 시간이 항상 인덱스 0에 있는지 확인합니다. 전체 작업을 람다 식으로 저장하여 44 바이트를 절약했습니다. 그 후 "저장 시간이 현재 시간과 같지 않으면 이전 시간을 현재 시간으로 설정하고 BONG n 번 인쇄하고 후행 공백을 제거하십시오"라는 논리로 들어갑니다.

체다가 가장 장황한 언어는 아니지만 다음과 같은 해결 방법을 찾는 것은 재미있을 수 있습니다!

슬프게도 이것은 Windows 전용 솔루션입니다.

편집 1 : for-condition의 "0 <1"을 "1"로 바꾸어 2 바이트를 절약했습니다.이 언어에서 1이 true로 평가되지는 않았습니다!

루비, 82 81 바이트

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

매초 우리는 시간의 마지막 초인지 확인하고 그에 따라 BONG. 더러운 속임수로 더 골프를 쳤을지도 모르지만 너무 많이 알지 못합니다. 또한 다른 Ruby 답변과 다르게 작동합니다.

QPaysTaxes 덕분에 1 바이트가 절약되었습니다.

파이썬 2 , 105106 바이트

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의 피드백 후 <를! =로 변경하여 1 바이트를 추가했습니다. 좋은 자리.

로컬에서 가능한 한 많이 테스트했지만 TIO에서는 60 초의 실행 제한을 초과하므로 TIO에서는 작동하지 않습니다. 현지에서 자유롭게 테스트하십시오 :-)

btw, 성가신 후행 공간을 잃어 버렸을 때 7 바이트가 들지 않으면 100 미만이었습니다.

TIO가 없으면 1 시간을 기다린 후 여기에 출력됩니다. Prog는 인쇄 시간 (12 시간 형식)을 보여주기 위해 추가 디버그 코드와 함께 15:27에 시작되었습니다.

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

파이썬 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");}}

자바 스크립트 ES6 87 바이트

편집 : new Date/36e5%12|0||126 바이트를 절약하기 위해 뻔뻔스럽게 @ETHProductions ' 코드를 빌 렸습니다.

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

매초마다 우리가 한 시간이 지 났는지 테스트하고 그 양을 인쇄해야 BONG합니다.

자바 스크립트 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문자를 저장하기 위해 지수 구문을 사용하여 1 시간 동안의 밀리 초 수입니다. new연산자는 인수가없는 경우 괄호 따라서, 기능을 사용하는 것을 필요로하지 않는다 new Date. JavaScript에는 부동 소수점 산술 만 있습니다. |비트 OR 연산자는 JS 비트 연산자가 IEEE 754 부동 소수점으로 표시되는 숫자의 정수 서브 세트로 작업하기 때문에 숫자를 정수로 만듭니다.

쉼표는 하위 표현식을 나타냅니다. p현재 시간 ( p=h())으로 초기화됩니다 .

for(;;)BONGs에 경고해야하는지 반복적으로 확인하는 데 사용됩니다 . 런타임이 허용하는 한 빨리 확인이 수행됩니다.

시간이 변경되면 ( h()!=p) p를 업데이트 한 다음 BONGs에 경고합니다 . 논리 AND 연산자는 가드 (이면 if 단락 h()===p)로 사용되어 BONGs가 출력 되는지 확인합니다 .

String.prototype.repeatES2015의 새로운 기능이며 ES5와 같은 것을 사용하여 일부 문자를 저장 Array.prototype.join합니다.

h12의 정확한 배수 (예 : 12pm, 12am)에 대해 0을 반환하므로 논리 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 바이트 (비경쟁)

BONG으로 가려면 엑셀을 얻는 것이 다소 어려울 수 있지만, 엑셀로 가려면 매우 간단합니다 Beep. Beep통화 1 초 일시에 의해 분리 된 시간에 대한 경고음 및 시간을 나타내는 경고음을 생산하기 위해 사용이 아래 코드를 생산.

위와 마찬가지로이 코드는 엑셀이 응답하지 않는 것처럼 보이게 :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
        }
    }
}

그루비, 72 바이트

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

어떻게?

현재 시간을 얻는 방법을 저장하십시오.

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

초기 시간을 저장하십시오.

y=x();

현재 시간이 이전 시간과 같지 않으면 출력 현재 시간에 "BONG"을 곱하여 현재 봉의 시간을 출력합니다.

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

%12비군 봉에 +3 바이트

펄, 60 바이트

최신 정보

대체 " "와 $"제거 CORE::, 수정 수입니다.

골프

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

로 실행해야합니다 perl -E.

비고

• perl에서 ( 단일 문장이있는 곳 x while y)과 동일 하지만 대괄호가 필요하지 않습니다. 인쇄하기 전에 처음으로 실행됩니다.while(y){x}xsleep
• timeUTC를 사용합니다. 원래 빅 벤은 3 월 말부터 10 월 말까지 서머 타임 (BST)에 있습니다.
• 프로그램이 최소 1 초 동안 대기 할 수 있도록 대기 시간에 1 초가 추가됩니다. 즉, BONG은 항상 1 초 늦게 인쇄되며 이는 규칙에 따라 합법적입니다. 웨스트 민스터 다리에 서 있다고 가정 해 봅시다. 빅 벤에서 300m 떨어져 있습니다. 플러스 측면에서 이것은 또한 정확히 3 시간 동안 (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로 2 바이트를 더 절약 할 수 있습니다. 그러나 나는 현재 너무 게으르다.

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