Difference between revisions of "User:Haxit/Kiloseconds"

From ArchWiki
Jump to: navigation, search
(use https for links to archlinux.org)
Line 837: Line 837:
 
     description => 'Reports the time in kiloseconds',
 
     description => 'Reports the time in kiloseconds',
 
     license => 'GPL',
 
     license => 'GPL',
     url => 'http://wiki.archlinux.org/index.php/Kiloseconds',
+
     url => 'https://wiki.archlinux.org/index.php/Kiloseconds',
 
     changed => 'no idea',
 
     changed => 'no idea',
 
  );  
 
  );  

Revision as of 00:48, 6 December 2012

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 { printf("It is %s kiloseconds.\n",(strftime("%H")*3600+strftime("%M")*60+strftime("%S"))/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)

LOLPython here

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 python

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