Formatted numeric output

Formatted numeric output
You are encouraged to solve this task according to the task description, using any language you may know.

Express a number in decimal as a fixed-length string with leading zeros.

For example, the number 7.125 could be expressed as "00007.125".

Ada

with Ada.Text_Io.Editing; use Ada.Text_Io.Editing;
with Ada.Text_Io; use Ada.Text_Io;

procedure Zero_Fill is
   Pic_String: String := "<999999.99>";
   Pic : Picture := To_Picture(Pic_String);
   type Money is delta 0.01 digits 8;
   package Money_Output is new Decimal_Output(Money);
   use Money_Output;
   
   Value : Money := 37.25;
begin
   Put(Item => Value, Pic => Pic);
end Zero_Fill;

The output of this program is

000037.25 

C

void printit(int val)
{
    printf ("%08d", val);    // Prints 8 digits with leading zeros
}

Forth

Forth has a rather rich set of number formatting words, which makes formatted output very flexible but sometime cumbersome.

Here one way to generate the required output. Note that the number generated is NOT truncated to the field width. If you wish to truncate the number, remove #s and 1- from the definition. (The 1- is necessary because #s always generates at least one digit, even if it's zero.)

\ format 'n' digits of the double word 'd'
: #n ( d n -- d )  0 ?do # loop ;

\ ud.0 prints an unsigned double
: ud.0 ( d n -- )  <# 1- #n #s #> type ;

\ d.0 prints a signed double
: d.0 ( d n -- )  >r tuck dabs <# r> 1- #n #s rot sign #> type ;

Usage example:

Type:    123 s>d  8 ud.0
Result:  00000123 ok
Type:    -123 s>d 8 d.0
Result:  -00000123 ok

IDL

n = 7.125
print, n, format='(f08.3)'
;==> 0007.125

J

   'r<0>15.9' (8!:2) 7.125
00007.125000000

   'r<$>15.9' (8!:2) 7.125
$$$$7.125000000

Java

Stealing printf from C/C++:

public class Printing{
	public static void main(String[] args){
		double printer = 7.125;
		System.out.printf("%09.3f",printer);
	}
}

JavaScript

var n = 123;
var str = ("00000" + n).slice(-5);
alert(str);

//or, put in browser URL: javascript:n=123;alert(("00000"+n).slice(-5));

Perl

Interpreter: Perl v5.x

my $num = 123.45
my $pad = '0' x (5 - length(int($num))) . $num;
# $pad is now 00123.45

Pop11

The task is underspecified, so we present a few alternatives.

 ;;; field of length 12, 3 digits after decimal place
 format_print('~12,3,0,`*,`0F', [1299.19]);
 ;;; prints "00001299.190"
 format_print('~12,3,0,`*,`0F', [100000000000000000]);
 ;;; Since the number does not fit into the field prints "************"
 ;;; that is stars instead of the number
 format_print('~12,3,0,`*,`0F', [-1299.19]);
 ;;; prints "000-1299.190"
 ;;; that is _leading zeros_ before sign

 format_print('~3,1,12,`0:$', [1299.19]);
 ;;; prints "00001299.190"
 format_print('~3,1,12,`0:$', [-1299.19]);
 ;;; prints "-0001299.190"
 ;;; that is sign before leading zeros
 format_print('~3,1,12,`0:$', [100000000000000000]);
 ;;; prints "100000000000000000.000"
 ;;; that is uses more space if the number does not fit into
 ;;; fixed width

Python

#tested in Python 2.4.1
n = 123
str = "%05d" % n  #5 places wide, leading zeros
print n, str
#output: 123 00123

Raven

7.125 "%09.3f" print

00007.125

SQL

Interpreter: MS SQL 2005

declare @n int
select @n=123
select substring(convert(char(5), 10000+@n),2,4) as FourDigits

set @n=5
print "TwoDigits: " + substring(convert(char(3), 100+@n),2,2)
--Output: 05

Tcl

set number 7.342
format "%08.3f" $number

Toka

needs values
value n
123 to n

2 import printf
" %08d" n printf

XSLT

<xsl:value-of select="format-number(7.125, '00000000.#############')" />