User:Haxit/Kiloseconds
The kiloseconds project is a very sophisticated and exquisite, ego-boosting and mind-blowing (albeit perhaps a bit over-engineered) project which aims to provide its audience with the time in kiloseconds, since we cannot live without it.
Please help use out by adding programming languages to our github repo [1]
Awk
#!/bin/awk -f
BEGIN {
patsplit(strftime("%T"), t, /[0-9]{2}/)
printf "It is %.3f kiloseconds.\n", (t[1]*3600 + t[2]*60 + t[3]) / 1000
}
Bash
Using seconds since 1970-01-01 00:00:00 UTC
echo "It's $((($(date +%s) - $(date +%s -d $(date +%x)))/1000)) kiloseconds."
Fixed invalid date bug of above ;)
echo "It's $((($(date +%s) - $(date +%s -d $(LC_ALL="C" date +%x)))/1000)) kiloseconds."
Another one, using sed
# date is only invoked once. This variant also outputs the fractional part. eval $(echo $(($(date +"%-H*3600+%-M*60+%-S")))|sed "s/.*/echo It is \$((&\/1000)).\$((&%1000)) kiloseconds./")
Befunge-93
Befunge-93 has no way of getting the time by itself so it has to be supplied on stdin, eg $date +"%H %M %S" | befungeinterpreter ks.bf
0" si tI">:#,_$&"d$"**&"<"*+&+:"d"52**/.0" tniop">:#,_$"d"52**%v ks.bf @$_ #!,#:<"kiloseconds."+550.<,"0"_v#`\+55:,"0"_v#`\"d":< Pipe date +"%H %M %S" to stdin. ^ < < .:tlvb
Brainf***
[ Usage: date +"%H%M%S"|somebfinterpreter ks.bf ] ++++++++++> >>++++[<++++++++<++++++++>>-] ++[<+++++++>-] >+++++++++[<++++++++>-]<+ >>>>>>>>>>>>++++++++++[<++++++++++>-] <[<<<<<<<<<<+>+>+>+>+>+>+>+>+>+>-] <<<<<<<<<<->>+>+++++>+++++++>++++++++ >>>>>+++++++++++++[<<<<+>+>+>+>-]<<<<--->-->++>+++ >,>,>,>,>,>,>>++++++[<++++++++>-]<[<<<<<<->->->->->->-] <[>+<-]<[>+<-]<[>>++++++<<-]<[>>++++++<<-] <[>>+++>++++++<<<-]<[>>+++>++++++<<<-] >>>>>[>>+>+<<<-]>>> [-[-[-[-[-[-[-[-[-[-<----------<<<+>>>> [-[-[-[-[-[-[-[-[-[-<----------<<<+>>>> [-[-[-[-[-[-[-[-[-[-<----------<<<+>>>> [-[-[-[-[-[-[-[-[-[-<----------<<<+>>>> [-[-[-[-[-[-[-[-[-[-<----------<<<+>>>> [-[-[-[-[-[-[-[-[-[-<----------<<<+>>>> ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] <[<<+>>-] <<<[>>>+>+<<<<-]>>>> [-[-[-[-[-[-[-[-[-[-<----------<<<<+>>>>> [-[-[-[-[-[-[-[-[-[-<----------<<<<+>>>>> [-[-[-[-[-[-[-[-[-[-<----------<<<<+>>>>> [-[-[-[-[-[-[-[-[-[-<----------<<<<+>>>>> [-[-[-[-[-[-[-[-[-[-<----------<<<<+>>>>> [-[-[-[-[-[-[-[-[-[-<----------<<<<+>>>>> [-[-[-[-[-[-[-[-[-[-<----------<<<<+>>>>> [-[-[-[-[-[-[-[-[-[-<----------<<<<+>>>>> [-[-[-[-[-[-[-[-[-[-<----------<<<<+>>>>> ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] ]]]]]]]]]] <[<<<+>>>-] <<<<[>>>>+>+<<<<<-]>>>>> [-[-[-[-[-[-[-[-[-[-<----------<<<<<+>>>>>> [-[-[-[-[-[-[-[-[-[-<----------<<<<<+>>>>>> [-[-[-[-[-[-[-[-[-[-<----------<<<<<+>>>>>> [-[-[-[-[-[-[-[-[-[-<----------<<<<<+>>>>>> ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] <[<<<<+>>>>-] >++++++[<++++++++>-]<[<<<<<+>+>+>+>+>-] <<<<<<<<<<<<<<<<<<.>>>>>>>>>>.<<<<<<<<<<<<.>>>>>>.>>>>>.<<<<<<<<<<<. >>>>>>>>>>>>>>>.>.<<<<<<<<<<<<<<< . >>>>>>>>>>>>>>>>.>.>. <<<<<<<<<<<<<<<<<<<.>>>>>>>.<.>>.>>.>.<<<<<<.>>>>>.<.<<<<<.>>>>>>>. <<<<<<<<<<<<.
C
#include <stdio.h>
#include <time.h>
int main(void)
{
struct tm *t;
time_t now;
float ks;
time(&now);
t=localtime(&now);
ks=(t->tm_hour*3600 + t->tm_min*60 + t->tm_sec);
printf("it is %.2f kiloseconds\n",ks/1000);
return 0;
}
C++
#include <iostream>
#include <ctime>
using namespace std;
int main()
{
time_t now;
time(&now);
struct tm *t = localtime(&now);
float ks = (t->tm_hour*3600 + t->tm_min*60 + t->tm_sec);
cout << "it is " << ks/1000 << " kiloseconds" << endl;
}
C#
// mcs ks.cs && mono ks.exe
using System;
public class HelloWorld {
static public void Main () {
DateTime dt = DateTime.Now;
Console.WriteLine ( Math.Round(
(decimal)((dt.Hour * 3600 + dt.Minute * 60 + dt.Second)/1000.0),
3).ToString());
}
}
Clojure
(import '(java.util Calendar))
(defn kiloseconds
"Current time in kiloseconds."
[]
(let [calendar (Calendar/getInstance)
hours (. calendar (get Calendar/HOUR_OF_DAY))
minutes (. calendar (get Calendar/MINUTE))
seconds (. calendar (get Calendar/SECOND))
kiloseconds (/ (+ (* hours 3600) (* minutes 60) seconds) 1000)]
(println (str "Kiloseconds: " (float kiloseconds)))))
;; call it
(kiloseconds)
Delphi
program Kiloseconds;
{$APPTYPE CONSOLE}
uses
SysUtils;
var
h,m,s,ms: word;
begin
DecodeTime(now, h, m, s, ms);
Writeln('It is ' + FloatToStrF( (h*3600 + m*60 + s) / 1000, ffNumber, 7, 2) + ' kiloseconds.');
end.
Eiffel
class
APPLICATION
inherit
ARGUMENTS
create
make
feature {NONE} -- Initialization
make
-- Run application.
local
time: TIME
kilo_seconds: INTEGER
do
create time.make_now
kilo_seconds := ((time.hour * 3600 + time.minute * 60 + time.second) / 1000).floor
io.put_integer (kilo_seconds)
io.new_line
end
end
Emacs Lisp
(require 'cl) (defun ks-from-time (seconds minutes hours) (/ (+ seconds (* minutes 60) (* hours 3600))1000.0)) (defun ks-time () (interactive) (message "It's %.3f ks" (apply 'ks-from-time (subseq (decode-time) 0 3)))) (defun erc-cmd-KS () (erc-send-message (format "It's %.3f ks" (apply 'ks-from-time (subseq (decode-time) 0 3)))))
Erlang
-module(kiloseconds).
-export([kilotime/0]).
kilotime() ->
{Hour,Minutes,Seconds} = erlang:time(),
io:format("It is ~w kiloseconds ~n", [(Hour * 3600 + Minutes * 60 + Seconds)/1000]).
Factor
USING: accessors calendar kernel math prettyprint ;
IN: kiloseconds
: kiloseconds ( -- n )
now [ hour>> 3600 * ] [ minute>> 60 * ]
[ second>> ] tri + + 1000 /i ;
: main ( -- )
kiloseconds . ;
MAIN: main
Forth
With floating point division
Simple example using floating point to divide the total number of seconds with 1000:
\ This runs at least in gforth \ $ gforth ks.fs : kiloseconds ( -- r ) time&date 2drop drop 60 * + 60 * + s>f 1e+3 f/ ; : printkstime ( -- ) ." It is " kiloseconds f. ." kiloseconds." cr ; printkstime bye
With custom printing function
Using ANS Forths 'pictured numeric output':
#! /usr/bin/gforth : shift ( a b -- c ) 60 * + ; : seconds ( -- sec ) time&date 2drop drop shift shift ; : .ks ( sec -- ) s>d <# # # # '. hold #s #> type ; ." it is " seconds .ks ." kiloseconds" cr bye
Fortran 90/95
To 17 decimal places:
program kiloseconds real*8 ksec ksec = secnds(0.0) / 1000 print 10, ksec 10 format( 'It is ', F20.17, ' kiloseconds.' ) end program
Go
// 8g ks.go && 8l -o ks ks.8 && ./ks
package main
import fmt "fmt"
import "time"
func main(){
d := time.LocalTime()
d.Hour = 0; d.Minute = 0; d.Second = 0;
fmt.Printf( "it is now %2.3f ks",
float(time.LocalTime().Seconds()-d.Seconds())/1000)
}
Haskell
import Data.Time
diffTimeToKiloSeconds diffTime = realToFrac diffTime / 1000
secondsSinceMidnight = timeOfDayToTime . localTimeOfDay . zonedTimeToLocalTime
kiloSecondsSinceMidnight = diffTimeToKiloSeconds . secondsSinceMidnight
main = do localTime <- getZonedTime
putStrLn $ "It's "
++ show (kiloSecondsSinceMidnight localTime)
++ " kiloseconds"
A version with fixed-width decimal output:
import Data.Time
import Numeric
diffTimeToKiloSeconds diffTime = realToFrac diffTime / 1000
secondsSinceMidnight = timeOfDayToTime . localTimeOfDay . zonedTimeToLocalTime
kiloSecondsSinceMidnight = diffTimeToKiloSeconds . secondsSinceMidnight
main = do localTime <- getZonedTime
putStrLn $ "It's "
++ showFFloat (Just 2) (kiloSecondsSinceMidnight localTime) ""
++ " kiloseconds"
A version with fixed-width decimal output using printf:
import Data.Time import Text.Printf secondsSinceMidnight :: ZonedTime -> Double secondsSinceMidnight = realToFrac . timeOfDayToTime . localTimeOfDay . zonedTimeToLocalTime main = do time <- getZonedTime printf "%.2f\n" (secondsSinceMidnight time / 1000)
IO
Date midnight := method(self clone setHour(0) setMinute(0) setSecond(0))
Date ks := method((self secondsSince(self midnight) / 1000) asString exSlice(0,6))
writeln("it is ", Date now ks, " kiloseconds")
Java
import java.util.GregorianCalendar;
public class Kiloseconds {
public static void main(String[] args) {
GregorianCalendar calendar = new GregorianCalendar();
float hours, minutes, seconds, kiloseconds;
hours = calendar.get(GregorianCalendar.HOUR_OF_DAY);
minutes = calendar.get(GregorianCalendar.MINUTE);
seconds = calendar.get(GregorianCalendar.SECOND);
kiloseconds = (hours*3600 + minutes*60 + seconds) / 1000;
System.out.println(kiloseconds + "\n");
}
}
Javascript
ourDate = new Date();
metricTime = (ourDate.getHours() * 3600 + ourDate.getMinutes() * 60 + ourDate.getSeconds());
document.write("It is: " + metricTime / 1000 + " kiloseconds.");
Lisp
(multiple-value-bind (seconds minutes hours)
(get-decoded-time)
(print (/ (+ seconds
(* minutes 60)
(* hours 3600))
1000.0)))
LOLCODE (LOLPython)
IN MAI time GIMME localtime LIKE NOW TODAYS CAN HAZ NOW THING KILOSECONDS CAN HAZ EASTERBUNNY PILE CAN HAZ CHEEZBURGER KILOSECONDS GETZ ANOTHR 3600 OF THOSE TODAYS OWN tm_hour KILOSECONDS GETZ ANOTHR 60 OF THOSE TODAYS OWN tm_min KILOSECONDS GETZ ANOTHR PILE OF THOSE TODAYS OWN tm_sec VISIBLE "OMG IT'S" AND KILOSECONDS SMASHES INTO 1000.0 AND "KILOSECONDS"
Lua
Printing once
This version displays the time once
print("It is ", (os.date("%H")*3600 + os.date("%M")*60 + os.date("%S"))/1000, " kiloseconds")
Continously looping
Time is updated once per second
while true do
io.write("\rIt is ", (os.date("%H")*3600 + os.date("%M")*60 + os.date("%S"))/1000, " kiloseconds")
io.stdout:flush()
os.execute("sleep 0.7")
end
Maple
with(StringTools, FormatTime):
t:= x->parse(FormatTime(x)):
printf("It is %2.2f kiloseconds\n", (t(%H)*3600 + t(%M)*60 + t(%S))/1000);
Mathematica
Drop[DateList[],3].{3600,60,1}/1000
MatLab
Verbose code
function ks = kiloseconds(); % make a clock c = clock; % get hour hour = c(4); % get minutes min = c(5); % get seconds sec = c(6); ks = (hour*3600+min*60+sec)/1000; end
Oneliner
function s=ks(); c=clock; s=sum(c(4:6).*[60^2 60 1])/1000; end
Objective-C (Cocoa)
NSDate *d = [NSDate date]; NSDateComponents *dc = [[NSCalendar currentCalendar] components:NSHourCalendarUnit|NSMinuteCalendarUnit|NSSecondCalendarUnit fromDate:d]; double ks = ([dc second] + [dc minute] * 60 + [dc hour] * 3600) / 1000.0; NSLog(@"%.3f", ks);
OCaml
#!/usr/bin/ocaml unix.cma open Unix;; let t = localtime (time ()) in let ks = float_of_int (t.tm_sec + t.tm_min * 60 + t.tm_hour * 3600) /. 1000.0 in Printf.printf "%.3f" ks;;
Openoffice.org's BASIC
function Kiloseconds()
Time = Now()
Kiloseconds = CStr((Hour(time)*3600 + Minute(time)*60 + Second(time))/1000) + " kiloseconds"
end function
Perl
#!/usr/bin/perl ($s,$m,$h) = localtime(); printf "Current time: %.3f kiloseconds.\n", ($h*3600+$m*60+$s)/1000;
PHP
<?php list($sec, $min, $hour) = localtime(time(), false); echo "Time is ", ($hour * 3600 + $min * 60 + $sec) / 1000, " kiloseconds\n";
PLT Scheme
(let* ([date-struct (seconds->date (current-seconds))]
[seconds (date-second date-struct)]
[minutes (date-minute date-struct)]
[hours (date-hour date-struct)])
(display (/ (+ seconds
(* minutes 60)
(* hours 3600))
1000.0)))
Powershell
((Date).get_Hour()*3600 + (Date).get_Minute()*60 + (Date).get_Second())/1000
Prolog (SWI-Prolog)
#!/usr/bin/env swipl -g kiloseconds -s
kiloseconds :-
get_time(T),
stamp_date_time(T,date(_,_,_,H,M,S,_,_,_),'local'),
format('It is: ~f kiloseconds.~n',[(H*3600+M*60+S)/1000]).
Python
Small example
import time tm = time.localtime() print (tm.tm_hour*3600+tm.tm_min*60+tm.tm_sec)/1000.0, "kiloseconds"
Big example (with Ncurses)
With fancy colours and everything ./curses_clock.py -h for usage You have been warned
#!/usr/bin/env python2
import curses
import signal
import traceback
import time
import getopt, sys
DIGIT_WIDTH = 5
DIGIT_HEIGHT = 5
DIGIT_SPACING = 2
'''
_0_0_._0_0_0_
'''
width = 7*DIGIT_SPACING + 6*DIGIT_WIDTH
height = 2*DIGIT_SPACING + DIGIT_HEIGHT
# numbers, list of coords in (y,x)
digits = [
[
"#####",
"# #",
"# #",
"# #",
"#####"
],
[
" # ",
" ## ",
" # ",
" # ",
" ### ",
],
[
"#####",
" #",
"#####",
"# ",
"#####",
],
[
"#####",
" #",
" ####",
" #",
"#####",
],
[
"# #",
"# #",
"#####",
" #",
" #",
],
[
"#####",
"# ",
"#####",
" #",
"#####",
],
[
"#####",
"# ",
"#####",
"# #",
"#####",
],
[
"#####",
" #",
" #",
" #",
" #",
],
[
"#####",
"# #",
"#####",
"# #",
"#####",
],
[
"#####",
"# #",
"#####",
" #",
" #",
],
[
"",
"",
"",
"",
" # ",
],
]
def draw_digit(win, digit, y, x):
sections = digits[digit]
position = 0
for section in sections:
xpos = x
for char in section:
if char == ' ':
win.addstr(position+y, xpos, ' ', curses.color_pair(0))
else:
win.addstr(position+y, xpos, ' ', curses.color_pair(1))
xpos += 1
position += 1
def draw_time(win, digits):
h,w = win.getmaxyx()
x_pos = (w - width) / 2
y_pos = (h - height) / 2
x_pos += DIGIT_SPACING
y_pos += 1
digits.insert(2, 10) #add in the point
for d in digits:
draw_digit(win, d, y_pos, x_pos)
x_pos += (DIGIT_SPACING + DIGIT_WIDTH)
def tick(win):
tm = time.localtime()
t = ks = tm.tm_hour*3600 + tm.tm_min*60 + tm.tm_sec
a = ks/10000; ks -= a*10000
b = ks/1000; ks -= b*1000
c = ks/100; ks -= c*100
d = ks/10; ks -= d*10
e = ks
draw_time(win, [a,b,c,d,e])
return t
def draw_dots(win):
h,w = win.getmaxyx()
x_pos = (w - width) / 2
y_pos = (h - height) / 2
win.hline(y_pos,x_pos,curses.ACS_BULLET, width, curses.color_pair(2))
win.hline(y_pos+DIGIT_HEIGHT+1,x_pos,curses.ACS_BULLET, width, curses.color_pair(2))
win.vline(y_pos+1,x_pos,curses.ACS_BULLET, DIGIT_HEIGHT, curses.color_pair(2))
win.vline(y_pos+1,x_pos+width-1,curses.ACS_BULLET, DIGIT_HEIGHT, curses.color_pair(2))
def init_screen():
screen = curses.initscr()
curses.noecho()
curses.cbreak()
screen.clear()
def main(screen, fg, bg):
curses.curs_set(0) #hide cursor
screen.nodelay(1) # do not wait for input
curses.use_default_colors()
curses.init_pair(1, fg, fg)
curses.init_pair(2, fg, bg)
screen.bkgd(' ', curses.color_pair(2))
def screen_resize(*args):
while 1:
try: curses.endwin(); break
except: time.sleep(1)
screen.erase()
draw_dots(screen)
screen.refresh()
signal.signal(signal.SIGWINCH, screen_resize)
draw_dots(screen)
t = None
while True:
newtime = tick(screen)
if t != newtime:
screen.refresh()
t = newtime
c = screen.getch()
if c == ord('q'):
break
time.sleep(0.5)
def usage():
print '''curses_clock.py [OPTION]
-h, --help displays this help
-f, --fg=COLORCODE sets the foreground color to COLORCODE
-b, --bg=COLORCODE sets the background color to COLORCODE
Color codes available:
default term fg/bg -1
black 0
red 1
green 2
yellow 3
blue 4
magenta 5
cyan 6
white 7
'''
if __name__ == '__main__':
bg = 0
fg = 7
def do_color(arg):
try:
color = int(arg)
except:
color = -1
if not -1 <= color <= 7:
print "Color code not in correct range"
usage()
sys.exit(2)
else:
return color
try:
opts, args = getopt.getopt(sys.argv[1:], "hf:b:", ["help", "fg=", "bg="])
except getopt.GetoptError:
usage()
sys.exit(2)
for opt, arg in opts:
if opt in ("-h", "--help"):
usage()
sys.exit()
elif opt in ("-f", "--fg"):
fg = do_color(arg)
elif opt in ("-b", "--bg"):
bg = do_color(arg)
curses.wrapper(main, fg, bg)
REBOL
REBOL [ Title: "kiloseconds" File: %ks.r ] f: to integer! now/time print f / 1000
Ruby
puts((Time.now.sec + Time.now.min*60 + Time.now.hour*3600) / 1000.0)
Scala
Could be done shorter, but this demonstrates some nice Scala features.
import java.util.Calendar
object Kilosecond {
private implicit def enrichCalendar(c: Calendar) = new CalendarWrapper(c)
def main(args: Array[String]) = {
val c = Calendar.getInstance
println("Kiloseconds: " + c.kiloseconds)
}
private class CalendarWrapper(c: Calendar) {
def kiloseconds = {
val hours = c.get(Calendar.HOUR_OF_DAY)
val minutes = c.get(Calendar.MINUTE)
val seconds = c.get(Calendar.SECOND)
(hours * 3600 + minutes * 60 + seconds) / 1000.0
}
}
}
Sed
Large
run with sed -f ks.sed
:ck;h
s/^[0-2][0-9] [0-5][0-9] [0-5][0-9]$//;tok
s/.*/Supply time on stdin in a format corresponding to what date "+%H %M %S" would output/
b
:ok;x
:s; s/^\(.. ..\) \(..\)/\1 000\2/;tm
:m; s/^.. .0/& 00000/;tm1
s/^.. .1/& 00060/;tm1; s/^.. .2/& 00120/;tm1; s/^.. .3/& 00180/;tm1
s/^.. .4/& 00240/;tm1; s/^.. .5/& 00300/;tm1; s/^.. .6/& 00360/;tm1
s/^.. .7/& 00420/;tm1; s/^.. .8/& 00480/;tm1; s/^.. .9/& 00540/;tm1
:m1;s/^.. 0./& 00000/;th0
s/^.. 1./& 00600/;th0; s/^.. 2./& 01200/;th0; s/^.. 3./& 01800/;th0;
s/^.. 4./& 02400/;th0; s/^.. 5./& 03000/;th0
:h0;s/^.0 ../& 00000/;th1
s/^.1 ../& 03600/;th1; s/^.2 ../& 07200/;th1; s/^.3 ../& 10800/;th1
s/^.4 ../& 14400/;th1; s/^.5 ../& 18000/;th1; s/^.6 ../& 21600/;th1
s/^.7 ../& 25200/;th1; s/^.8 ../& 28800/;th1; s/^.9 ../& 32400/;th1
:h1;s/^0. ../00000/;tsp
s/^1. ../36000/;tsp
s/^2. ../72000/;tsp
:sp;s/$/|/
:d4;s/\<\(.\)\(....\>.*|.*\)/\2\1/;td4; s/$/ /
:d3;s/\<\(.\)\(...\>.*|.*\)/\2\1/;td3; s/$/ /
:d2;s/\<\(.\)\(..\>.*|.*\)/\2\1/;td2; s/$/ /
:d1;s/\<\(.\)\(.\>.*|.*\)/\2\1/;td1; s/$/ /
:d0;s/\<\(.\)\(\>.*|.*\)/\2\1/;td0; s/$/ /
:c0;s/.*|//
s/0//g
s/1/o/g
s/2/oo/g
s/3/ooo/g
s/4/oooo/g
s/5/ooooo/g
s/6/oooooo/g
s/7/ooooooo/g
s/8/oooooooo/g
s/9/ooooooooo/g
:+; s/\(.*\) oooooooooo\(.*\)/\1o \2/;t+
:c1;s/ooooooooo /9/g
s/oooooooo /8/g
s/ooooooo /7/g
s/oooooo /6/g
s/ooooo /5/g
s/oooo /4/g
s/ooo /3/g
s/oo /2/g
s/o /1/g
s/ /0/g
:c2;s/\(..\)\(...\)/It is \1.\2 kiloseconds./
:zp;s/0\(.\)\./\1./
Smaller
run with sed -f ks.sed
:00;s/^[0-2][0-9] *[0-5][0-9] *[0-5][0-9]$/&/;t02
:01;s/.*/Suggestion: date "+%H %M %S" | stdin./;q
:02;s/ //g;x;s/^/5/;x;t03
:03;s/^\(|*\)0/\1/;t08;s/^\(|*\)9/\1|||||||||/;t08;
:04;s/^\(|*\)1/\1|/;t08;s/^\(|*\)8/\1||||||||/;t08;
:05;s/^\(|*\)2/\1||/;t08;s/^\(|*\)7/\1|||||||/;t08;
:06;s/^\(|*\)3/\1|||/;t08;s/^\(|*\)6/\1||||||/;t08;
:07;s/^\(|*\)4/\1||||/;t08;s/^\(|*\)5/\1|||||/;t08;
:08;x;s/0//;x;t0d;:tlvb
:09;x;s/5/4/;s/3/2/;s/1/0/;x;t0b
:0a;x;s/4/3/;s/2/1/;x;t0c
:0b;s/|/||||||||||/g;t03;b03
:0c;s/|/||||||/g;t03;b03
:0d;s/|\{10\}/{/g;s/{$/{0/;
:0e;s/{\{10\}/}/g;s/}\([|0]\)/}0\1/
:0f;s/}\{10\}/(/g;s/(\([{0]\)/(0\1/
:10;s/(\{10\}/)/g;s/)\([}0]\)/)0\1/
:11;y/|{}()/{}()+/
:12;s/+\{9\}/9/;s/+\{8\}/8/;s/+\{7\}/7/;s/+\{6\}/6/;
:13;s/+\{5\}/5/;s/+\{4\}/4/;s/+\{3\}/3/;s/+\{2\}/2/;
:14;s/+/1/;s/[|{}()]/&/;t11
:15;s/^.\{0,3\}$/0&/;t15;
:16;s/\(.*\)\(.\{3\}\)/It is \1.\2 kiloseconds./
Smalltalk
'It is ', (Time now asSeconds/1000.000) printString, ' kiloseconds'
Standard ML
open Date; let val t = fromTimeLocal (Time.now ()) val ks = real (second t + minute t * 60 + hour t * 3600) / 1000.0 in print (Real.fmt (StringCvt.FIX (SOME 3)) ks) end;
Supybot
echo Today is [Math calc [echo ($YEAR * 365 + $MONTH * 12 + $DATE * 24) / 1000]] and the time is currently [Math calc [echo ($HOUR * 3600 + $MINUTE * 60 + $SECOND)/1000]] $TZ.
TCL
puts "It's [expr [clock format [clock seconds] -format {(%k*3600+%M.0*60+%S.0)/1000}]] kiloseconds"
Weechat Plugin
Requires weechat version 0.3.0+
kiloseconds.py
IRSSI Plugin
#!/usr/bin/perl use vars qw($VERSION %IRSSI); use Irssi; use strict; $VERSION = '0.10'; %IRSSI = ( authors => 'Ben Duffield', contact => 'jebavarde AT gmail DOT com', name => 'kiloseconds', description => 'Reports the time in kiloseconds', license => 'GPL', url => 'https://wiki.archlinux.org/index.php/Kiloseconds', changed => 'no idea', ); sub cmd_kiloseconds { my ($data, $server, $witem) = @_; my $output; my $ks; my $s; my $m; my $h; ($s,$m,$h) = localtime(); $ks = ($h*3600+$m*60+$s)/1000; $output = sprintf("Current time: %.3f kiloseconds", $ks); if ($output) { if ($witem && ($witem->{type} eq "CHANNEL" || $witem->{type} eq "QUERY")) { $witem->command("MSG ".$witem->{name}." $output"); } else { Irssi::print("This is not a channel/query window :b"); } } } Irssi::command_bind('kiloseconds', 'cmd_kiloseconds');
Oracle SQL
select ((to_char(sysdate,'HH')*60*60)+(to_char(sysdate,'MM')*60)+(to_char(sysdate,'SS')))/1000 as "Kiloseconds" from dual