DouKaku?

b = gets.to_i
if b < 10**3
    puts b
elsif b < 10**6
    puts "%.1fk" % (b.to_f/10**3)
elsif b < 10**9
    puts "%.1fM" % (b.to_f/10**6)
elsif b < 10**12
    puts "%.1fG" % (b.to_f/10**9)
else
    puts "%.1fT" % (b.to_f/10**12)
end

<transform version="2.0" xmlns="http://www.w3.org/1999/XSL/Transform" xmlns:y="y">
<output method="text"/><param name="n"/>
<variable name="u" select="('B','KiB','MiB','GiB','TiB','PiB','EiB','ZiB','YiB')"/>
<template match="/"><value-of select="y:f($n,1)"/></template>
<function name="y:f"><param name="m"/><param name="i"/>
<sequence select="if($m&lt;1024)then($m,$u[$i])else
y:f(round-half-to-even($m div 1024,2),$i+1)"/>
</function></transform>

using System;
class P {
    static void Main() {
        double n = double.Parse(Console.ReadLine());
        string s = " kMGTPEZY";
        int c = 0, l = 1000;
        for (; n >= l; c++)
            n /= l;
        Console.WriteLine("{0:f1}{1}", n, s[c]);
    }
}

#include <stdio.h>

#define QWORD unsigned long long
#define DWORD unsigned long
#define WORD  unsigned short
#define BYTE  char

int put_unit(char * p,int n,char u){
    if(n) return sprintf(p,"%d%c",n,u);
    if(u=='B') return sprintf(p,"B");
    return 0;
}

void conv_byte(char *p,QWORD num){
    int i;
    if(num==0) sprintf(p++,"0");
    for(i=6;i>=0;i--)
        p+=put_unit(p,(num>>(10*i))&0x3ff,"BKMGTPE"[i]);
}

void conv_put(char *buf,QWORD n){
    conv_byte(buf,n);
    printf("%Ld=%s\n",n,buf);    
}
int main(){
    char buf[64];
    
    conv_put(buf,0);
    conv_put(buf,(BYTE)-1);
    conv_put(buf,(WORD)-1);
    conv_put(buf,(DWORD)-1);
    conv_put(buf,(QWORD)-1);
    
    return 0;
}

| byte |
byte := 123456789012345.
^(#('' k M G T P E Z) inject: byte into: [:result :unit |
    result < 1024 ifTrue: [^result asString, unit].
    result / 1024 roundTo: 0.1]) asString, 'Y'

"=> '112.3T' "

$i=int(((($n=<>)=~tr/0-9/0-9/)-1)/3);
printf(($i?"%.1f":"%d")."%s\n",$n/10**($i*3),('',qw(k M G T P E Z Y))[$i])

class P{
    public static void main(String[]a){
        double d=Double.parseDouble(a[0]);
        int i=0,l=1000;
        for(;d>=l;d/=l,i++);
        System.out.printf("%.1f%s",d," kMGTPEZY".charAt(i));
    }
}

(function (d) {
  for (var i = 0; d >= 1024; d /= 1024, i++);
  alert(d.toFixed(2) + ' kMGTPEZY'.charAt(i));
})(123456789012345);

def readable(byte, base=1024):
  '''
  >>> readable(0)
  '0'
  >>> readable(100)
  '100'
  >>> readable(1024)
  '1.0k'
  >>> readable(1900*1024)
  '1.9M'
  >>> readable(1900*1024*1024)
  '1.9G'
  >>> readable(1900*(1024**7))
  '1.9Y'
  '''
  for c in ['','k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y']:
    d, m = divmod(byte, base)
    if not d:
      if c:
        return '%.1f%s'%(float(exp)/base, c)
      else:
        return str(m)
    else:
      exp = byte
      byte = d
  return 'Not supported'


if __name__ ==  '__main__':
  import doctest
  doctest.testmod()

bytes.pretty <- function(n){
  u <- c('', 'k', 'M', 'G', 'T')
  r <- 1024^(1:length(u)-1)
  i <- which.min(abs(512-n/r))
  sprintf("%.1f%s", n/r[i], u[i])
}

exit wd;(a<1e3){a;~(0j1":a%10^3*b),(b=.((a=.x:".}:1!:1[3)>10^3*i.5)i:1){' kMGT'

s=raw_input();p=-min(4,(len(s)-1)/3)*3;print[s,s[:p]+'.'+s[p:1+p]+'kMGT'[-1-p/3]][p<0]

#!/usr/bin/env gosh
(define-class <b> ()
  ((b :init-keyword :b :accessor b-b)))

(define-method write-object ((b <b>) port)
  (let* ((j (b-b b))
         (k 1000.0)
         (l '(byte k M G T P E Z Y))
         (m (min (truncate->exact (/ (log j) (log k)))
                 (- (length l) 1))))
    (if (< j k)
        (display j)
        (display (/ (truncate (* (/ j (expt k m)) 10)) 10)))
    (print (list-ref l m))))

(define (main args)
  (display "input: ")(flush)
  (print (make <b> :b (x->number(read)))))

/^..\?.\?$/b
s/$/.0kMGT/
:a
s/\(.\)\(.\)..\...\(.\)/\1.\2\3/
ta
s/\(\...\).*/\1/

#include <iostream>

template <bool b, class T, class S> struct Choice { typedef T Result; };
template <class T, class S> struct Choice<false, T, S> { typedef S Result; };

struct None
{
    enum { symbol = ' ' };
    static double scaled(long long n) throw() 
      { return static_cast<double>(n); }
};
struct Kilo
{
    enum { symbol = 'K' };
    static double scaled(long long n) throw() 
      { return static_cast<double>(n) / 1000LL; }
};
struct Mega
{
    enum { symbol = 'M' };
    static double scaled(long long n) throw() 
      { return static_cast<double>(n) / 1000000LL; }
};
struct Giga
{
    enum { symbol = 'G' };
    static double scaled(long long n) throw() 
      { return static_cast<double>(n) / 1000000000LL; }
};
struct Tera
{
    enum { symbol = 'T' };
    static double scaled(long long n) throw() 
      { return static_cast<double>(n) / 1000000000000LL; }
};

template <long long n>
struct SIPrefix
{
    typedef
        typename Choice< n <          1000LL, None,
        typename Choice< n <       1000000LL, Kilo,
        typename Choice< n <    1000000000LL, Mega,
        typename Choice< n < 1000000000000LL, Giga,
                                              Tera
      >::Result>::Result>::Result>::Result  Result;
};

template <long long n>
struct HumanReadable
{
private:
    typedef typename SIPrefix<n>::Result prefix;
    friend std::ostream& operator << (std::ostream& os, struct HumanReadable<n>)
      {
        os << prefix::scaled(n) << static_cast<char>(prefix::symbol);
      }
};

int main()
{
    std::cout << HumanReadable<123456789012345LL>() << std::endl;
    return 0;
};