Nautical bell: Difference between revisions

 

=={{header|AppleScript}}==

This version uses local time and speaks the bell rings using OS X's built-in speech synthesizer.

 

set {hours:h, minutes:m} to (current date)

if {0, 30} contains m then

end if

delay 60

 

=={{header|AutoHotkey}}==

Hr := 0, min := 30, Bells := [], pattern := []

Loop 8 ; genrate 8 patterns

Bells[00 ":" 00] := Bells[24 ":" 00] , numBells := Bells[hh ":" mm]

return {"bells": numBells, "pattern": Pattern[numBells]}

loop, 24

{

}

MsgBox, 262144, , % "Time`tBells`tPattern`n" res

Outputs:<pre>Time Bells Pattern

00:00 8 ** ** ** **

 

Alternatively, you could remove the forever loop and set it up to run every half hour via launchd or cron.

=={{header|AWK}}==

# syntax: GAWK -f NAUTICAL_BELL.AWK

BEGIN {

return(new_str)

}

<p>Output:</p>

<pre>

Implementation corrected, sounds the system bell as per nautical standards, sounds bell as per local system time.

 

#include<unistd.h>

#include<stdio.h>

}

 

 

=={{header|C++}}==

This version uses local time.

#include <iostream>

#include <string>

}

//--------------------------------------------------------------------------------------------------

Output:

<pre>

=={{header|D}}==

This code uses local time instead of Greenwich Mean Time.

 

class NauticalBell : Thread {

writeln(e.msg);

}

This output is from an actual test run.

<pre>

08:30:00 : 1 bell

09:00:00 : 2 bells</pre>

 

=={{header|Go}}==

Provided your terminal bell is enabled, this should beep an appropriate number of times before displaying its output. It uses local time.

 

import (

time.Sleep(1 * time.Second)

}

 

{{out}}

=={{header|Haskell}}==

This solution first creates a general way of scheduling tasks on a time interval, and then schedules a "ringing" task. If used in a terminal it will also produce noise. Local time is used.

import Control.Concurrent

import Control.Monad

bellRinger = doWithScheduler (onInterval (30*60)) ringBells

 

 

{{out}}

 

=={{header|J}}==

 

 

WATCH =: <;._1 ' Middle Morning Forenoon Afternoon Dog First'

end.

y

 

 

'''Notes''': I tested the <tt>clock2ship</tt>, <tt>callWatch</tt>, and <tt>ringBell</tt> functions, but didn't actually have the patience to test <tt>shipsWatch</tt> over a 24-hour period. Use at your own risk (but don't use it to keep watch on your galleon, please).

This code uses UTC time.

{{trans|D}}

import java.text.SimpleDateFormat;

import java.util.TimeZone;

}

}

 

Sample output:

14:00:00 : 4 bells

...</pre>

 

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.text.DateFormat

}

}

 

Sample output:

</pre>

 

Works on version 11.2 ARM, a bug prevents this from working on version 11.3 Win64.

EmitSound[Sound[Table[{

SoundNote["C",750/1000,"TubularBells"],SoundNote[None,500/1000,"TubularBells"]

},Mod[Round[Total[DateList[][[{4,5}]]{2,1/30}]],8,1]]]]

 

=={{header|OoRexx}}==

{{trans|REXX}}

Parse Arg msg

If msg='?' Then Do

Return res

 

 

=={{header|Perl}}==

binmode STDOUT, ":utf8";

use DateTime;

}

print "\n";

{{out}}

<pre style="height:35ex">00:30 Middle watch, One Bell Gone: ♪

23:30 First watch, Seven Bells Gone: ♫ ♫ ♫ ♪

24:00 First watch, Eight Bells Gone: ♫ ♫ ♫ ♫</pre>

 

=={{header|Phix}}==

instead of <code>date(DT_GMT)</code>.<br>

Uses a full-length sleep of up to 1800 seconds (half an hour), as it should.

{{out}}

<pre>

=={{header|PL/I}}==

This program sounds the bell as well as displaying "gong" an appropriate number of times. It operates on local time.

nautical: procedure options (main); /* 29 October 2013 */

declare (hour, t, i) fixed binary;

end;

end nautical;

 

=={{header|PowerShell}}==

function Get-Bell

{

Get-Bell -Hour $_ -Minute 30

}

{{Out}}

<pre>

=={{header|Python}}==

As well as typing output to stdout, this program plays a sound for each bell as the ␇ characters are printed (The spaces between the ␇ characters are mirrored as varying delays between each ring).

 

duration = 750 # Bell duration in ms

if __name__ == '__main__':

{{out}}

<pre>00:00, First watch 8 bells ␇ ␇ ␇ ␇ ␇ ␇ ␇ ␇

that displays \a by playing the system bell, it will play the system bell.

 

 

(require racket/date)

(wait-til s)

(format-and-print hours (add1 bells))))

 

This might produce the following output:

</pre>

 

 

=={{header|REXX}}==

Also, some REXXes don't have a &nbsp; '''sound''' &nbsp; BIF, &nbsp; which produces sounds via the PC speaker,

&nbsp; so one is included &nbsp; <big> [[SOUND.REX|here]]. </big>

echo= ( arg()\==0 ) /*echo time and bells if any arguments.*/

signal on halt /*allow a clean way to stop the program*/

call delay 60; if rc\==0 then leave /*ensure we don't re─peel. */

end /*forever*/

{{out|output|text=&nbsp; when using the input of: &nbsp; <big> <tt> the time is: </tt> </big>}}

<pre>

 

=={{header|Ring}}==

# Project : Nautical bell

 

ok

next

Output:

<pre>

 

=={{header|Ruby}}==

watch_ends = [ "00:00", "04:00", "08:00", "12:00", "16:00", "18:00", "20:00", "23:59" ]

words = ["One","Two","Three","Four","Five","Six","Seven","Eight"]

end

sleep 1

 

{{out|Sample output}}

 

=={{header|Seed7}}==

include "time.s7i";

include "duration.s7i";

flush(OUT);

end while;

 

{{out}}

 

=={{header|Tcl}}==

# using the Snack library.

proc ringTheBell {} {

fconfigure stdout -buffering none

every 1000 nauticalBell

{{out|Sample output}}

<pre>

18:30 Last dog watch, Five Bells Gone: ♫ ♫ ♪

⋮

</pre>