Non-decimal radices/Output

From Rosetta Code
Jump to: navigation, search
Task
Non-decimal radices/Output
You are encouraged to solve this task according to the task description, using any language you may know.
Programming languages often have built-in routines to convert a non-negative integer for printing in different number bases. Such common number bases might include binary, Octal and Hexadecimal.

Show how to print a small range of integers in some different bases, as supported by standard routines of your programming language. (Note: this is distinct from Number base conversion as a user-defined conversion function is not asked for.)

The reverse operation is Common number base parsing.

Contents

[edit] Ada

with Ada.Integer_Text_IO;  use Ada.Integer_Text_IO;
with Ada.Text_IO; use Ada.Text_IO;
 
procedure Test_Integer_Text_IO is
begin
for I in 1..33 loop
Put (I, Width =>3, Base=> 10);
Put (I, Width =>7, Base=> 16);
Put (I, Width =>6, Base=> 8);
New_Line;
end loop;
end Test_Integer_Text_IO;

Sample output:

  1  16#1#  8#1#
  2  16#2#  8#2#
  3  16#3#  8#3#
  4  16#4#  8#4#
  5  16#5#  8#5#
  6  16#6#  8#6#
  7  16#7#  8#7#
  8  16#8# 8#10#
  9  16#9# 8#11#
 10  16#A# 8#12#
 11  16#B# 8#13#
 12  16#C# 8#14#
 13  16#D# 8#15#
 14  16#E# 8#16#
 15  16#F# 8#17#
 16 16#10# 8#20#
 17 16#11# 8#21#
 18 16#12# 8#22#
 19 16#13# 8#23#
 20 16#14# 8#24#
 21 16#15# 8#25#
 22 16#16# 8#26#
 23 16#17# 8#27#
 24 16#18# 8#30#
 25 16#19# 8#31#
 26 16#1A# 8#32#
 27 16#1B# 8#33#
 28 16#1C# 8#34#
 29 16#1D# 8#35#
 30 16#1E# 8#36#
 31 16#1F# 8#37#
 32 16#20# 8#40#
 33 16#21# 8#41#

[edit] Aime

o_xinteger(16, 1000000);
o_byte('\n');
o_xinteger(5, 1000000);
o_byte('\n');
o_xinteger(2, 1000000);
o_byte('\n');

[edit] ALGOL 68

Translation of: C
Works with: ALGOL 68 version Revision 1 - no extensions to language used
Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny
main:(
FOR i TO 33 DO
printf(($10r6d," "16r6d," "8r6dl$, BIN i, BIN i, BIN i))
OD
)

Sample output:

000001 000001 000001
000002 000002 000002
000003 000003 000003
000004 000004 000004
000005 000005 000005
000006 000006 000006
000007 000007 000007
000008 000008 000010
000009 000009 000011
000010 00000a 000012
000011 00000b 000013
000012 00000c 000014
000013 00000d 000015
000014 00000e 000016
000015 00000f 000017
000016 000010 000020
000017 000011 000021
000018 000012 000022
000019 000013 000023
000020 000014 000024
000021 000015 000025
000022 000016 000026
000023 000017 000027
000024 000018 000030
000025 000019 000031
000026 00001a 000032
000027 00001b 000033
000028 00001c 000034
000029 00001d 000035
000030 00001e 000036
000031 00001f 000037
000032 000020 000040
000033 000021 000041

[edit] AutoHotkey

contributed by Laszlo on the ahk forum

MsgBox % BC("FF",16,3) ; -> 100110 in base 3 = FF in hex = 256 in base 10
 
BC(NumStr,InputBase=8,OutputBase=10) {
Static S = 12345678901234567890123456789012345678901234567890123456789012345
DllCall("msvcrt\_i64toa","Int64",DllCall("msvcrt\_strtoui64","Str",NumStr,"Uint",0,"UInt",InputBase,"CDECLInt64"),"Str",S,"UInt",OutputBase,"CDECL")
Return S
}

[edit] AWK

C's printf() is just exposed:

$ awk '{printf("%d 0%o 0x%x\n",$1,$1,$1)}'
10
10 012 0xa
16
16 020 0x10
255
255 0377 0xff

[edit] BBC BASIC

      REM STR$ converts to a decimal string:
PRINT STR$(0)
PRINT STR$(123456789)
PRINT STR$(-987654321)
 
REM STR$~ converts to a hexadecimal string:
PRINT STR$~(43981)
PRINT STR$~(-1)

Output:

0
123456789
-987654321
ABCD
FFFFFFFF

[edit] Bc

Variable obase is the base for all output. It can be 2 (binary) up to some implementation-dependent limit. In GNU bc the limit may be large, for example 2^31, with "digits" of bases bigger than 36 printed as individual decimal numbers.

Works with: GNU bc
 
for(i=1;i<10;i++) {
obase=10; print i," "
obase=8; print i," "
obase=3; print i," "
obase=2; print i
print "\n"
}

[edit] C

#include <stdio.h>
 
int main()
{
int i;
 
for(i=1; i <= 33; i++)
printf("%6d %6x %6o\n", i, i, i);
 
return 0;
}

Binary conversion using %b is not standard.

[edit] C++

#include <iostream>
#include <iomanip>
 
int main()
{
for (int i = 0; i <= 33; i++)
std::cout << std::setw(6) << std::dec << i << " "
<< std::setw(6) << std::hex << i << " "
<< std::setw(6) << std::oct << i << std::endl;
 
return 0;
}

Binary conversion is not standard.

[edit] Clojure

Clojure eschews duplicating functionality already present in Java when interop is sufficiently idiomatic:

(Integer/toBinaryString 25) ; returns "11001"
(Integer/toOctalString 25) ; returns "31"
(Integer/toHexString 25) ; returns "19"
 
(dotimes [i 20]
(println (Integer/toHexString i)))

[edit] Common Lisp

(loop for n from 0 to 33 do
(format t " ~6B ~3O ~2D ~2X~%" n n n n))

[edit] D

import std.stdio;
 
void main() {
writeln("Base: 2 8 10 16");
writeln("----------------------------");
foreach (i; 0 .. 34)
writefln(" %6b %6o %6d %6x", i, i, i, i);
}
Output:
Base: 2      8     10     16
----------------------------
      0      0      0      0
      1      1      1      1
     10      2      2      2
     11      3      3      3
    100      4      4      4
    101      5      5      5
    110      6      6      6
    111      7      7      7
   1000     10      8      8
   1001     11      9      9
   1010     12     10      a
   1011     13     11      b
   1100     14     12      c
   1101     15     13      d
   1110     16     14      e
   1111     17     15      f
  10000     20     16     10
  10001     21     17     11
  10010     22     18     12
  10011     23     19     13
  10100     24     20     14
  10101     25     21     15
  10110     26     22     16
  10111     27     23     17
  11000     30     24     18
  11001     31     25     19
  11010     32     26     1a
  11011     33     27     1b
  11100     34     28     1c
  11101     35     29     1d
  11110     36     30     1e
  11111     37     31     1f
 100000     40     32     20
 100001     41     33     21

[edit] Tango Version

Number following formatting character is width. When no formatting character is specified it is inferred from variable's type.

Library: Tango
for (int i = 0; i < 35; i++)
Stdout.formatln ("{:b8} {:o3} {} {:x2}", i, i, i, i);

[edit] E

for value in 0..33 {
for base in [2, 8, 10, 12, 16, 36] {
def s := value.toString(base)
print(" " * (8 - s.size()), s)
}
println()
}

[edit] Erlang

Printing 63 (decimal) in some different bases (here: 3,8,16,26). The base can be 2..36.

Output:
4> [io:fwrite("~s ", [erlang:integer_to_list(63, X)]) || X <- [3,8,16,26]].
2100 77 3F 2B

[edit] Euphoria

for i = 1 to 33 do
printf(1,"%6d %6x %6o\n",{i,i,i})
end for

[edit] Factor

1234567 2 36 [a,b] [ >base print ] with each
100101101011010000111
2022201111201
10231122013
304001232
42243331
13331215
4553207
2281451
1234567
773604
4b6547
342c19
241cb5
195be7
12d687
ed4ea
bdc71
98ig4
7e687
6769j
55kgf
49ahj
3h787
3407h
2i679
28jdj
206jj
1lhs8
1flm7
1adkn
15lk7
11bm4
vdwr
srsc
qglj

[edit] Forth

Works with: GNU Forth

GNU Forth has convenience functions for printing an integer in decimal or hex, regardless of the current BASE.

: main 34 1 do cr i dec. i hex. loop ;
main
...
11 $B
...

This is not standardized because such functions are very easy to define as needed:

: base. ( n base -- ) base @ >r  base !  .  r> base ! ;
: oct. ( n -- ) 8 base. ;
: bin. ( n -- ) 2 base. ;

[edit] Fortran

Works with: Fortran version 90 and later
do n = 1, 33
write(*, "(b6, o4, i4, z4)") n, n, n, n
end do

[edit] Gema

After decimal numbers in the input stream, add hexadecimal and octal of the same number in the output stream. Also after hexadecimal add decimal and octal, and after octal add decimal and hexadecimal.

0x<A>=$0 (@radix{16;10;$1}, 0@radix{16;8;$1})
0<D>=$0 (@radix{8;10;$1}, 0x@radix{8;16;$1})
<D>=$0 (0x@radix{10;16;$1}, 0@radix{10;8;$1})

Invocation and sample input and output

$ gema -p radix.gema
The 99 beers and 0x2D Scotches.
The 99 (0x63, 0143) beers and 0x2D (45, 055) Scotches.

[edit] Go

package main
 
import (
"fmt"
"math/big"
"strconv"
)
 
func main() {
// fmt.Print formats integer types directly as bases 2, 8, 10, and 16.
fmt.Printf("%b\n", 13)
fmt.Printf("%o\n", 13)
fmt.Printf("%d\n", 13)
fmt.Printf("%x\n", 13)
// big ints work with fmt as well.
d := big.NewInt(13)
fmt.Printf("%b\n", d)
fmt.Printf("%o\n", d)
fmt.Printf("%d\n", d)
fmt.Printf("%x\n", d)
// strconv.FormatInt handles arbitrary bases from 2 to 36 for the
// int64 type. There is also strconv.FormatUInt for the uint64 type.
// There no equivalent for big ints.
fmt.Println(strconv.FormatInt(1313, 19))
}
Output:
1101
15
13
d
1101
15
13
d
3c2

[edit] Haskell

import Text.Printf
 
main :: IO ()
main = mapM_ f [0..33] where
f :: Int -> IO ()
f n = printf " %3o %2d %2X\n" n n n -- binary not supported

alternately, without Text.Printf:

import Numeric
 
main :: IO ()
main = mapM_ f [0..33] where
f :: Int -> IO ()
f n = putStrLn $ " " ++ showOct n "" ++ " " ++ show n ++ " " ++ showHex n ""

[edit] HicEst

DO n = 1, 33
WRITE(Format="b6.0, o4.0, i4.0, z4.0") n, n, n, n
ENDDO

[edit] Icon and Unicon

Strictly speaking output conversion to different representations isn't built-in to Icon and Unicon; however, printf is included as part of the standard library.

rocedure main()
write("Non-decimal radices/Output")
every i := 255 | 2 | 5 | 16 do {
printf("%%d = %d\n",i) # integer format
printf("%%x = %x\n",i) # hex format
printf("%%o = %o\n",i) # octal format
printf("%%s = %s\n",i) # string format
printf("%%i = %i\n",i) # image format
}
end

printf.icn provides printf, fprintf, and sprintf

Output:
%d = 255
%x = ff
%o = 377
%s = 255
%i = 255
...

[edit] J

J can natively break out numbers using a specific base

   2 #.inv 12
1 1 0 0
3 #.inv 100
1 0 2 0 1
16 #.inv 180097588
10 11 12 1 2 3 4

However, this numeric representation would not satisfy most people's idea of "formatting", for most bases. It might be useful, however, for bases less than 10:

   8 #.inv 4009
7 6 5 1
-.&' '": 8 #.inv 4009
7651

J also includes some explicit support for hexadecimal numbers

  require 'convert'
hfd 180097588
ABC1234

(and a few other hexadecimal related mechanisms which are not relevant here.)

[edit] Java

public static void main(String args[]){
for(int a= 0;a < 33;a++){
System.out.println(Integer.toBinaryString(a));
System.out.println(Integer.toOctalString(a));
System.out.println(Integer.toHexString(a));
//the above methods treat the integer as unsigned
//there are also corresponding Long.to***String() methods for long's.
 
System.out.printf("%3o %2d %2x\n",a ,a ,a); //printf like the other languages; binary not supported
}
}

[edit] JavaScript

The number.toString(radix) method produces a string representation of a number in any radix between 2 and 36.

var bases = [2, 8, 10, 16, 24];
for (var n = 0; n <= 33; n++) {
var row = [];
for (var i = 0; i < bases.length; i++)
row.push( n.toString(bases[i]) );
print(row.join(', '));
}

outputs

0, 0, 0, 0, 0
1, 1, 1, 1, 1
10, 2, 2, 2, 2
11, 3, 3, 3, 3
100, 4, 4, 4, 4
101, 5, 5, 5, 5
110, 6, 6, 6, 6
111, 7, 7, 7, 7
1000, 10, 8, 8, 8
1001, 11, 9, 9, 9
1010, 12, 10, a, a
1011, 13, 11, b, b
1100, 14, 12, c, c
1101, 15, 13, d, d
1110, 16, 14, e, e
1111, 17, 15, f, f
10000, 20, 16, 10, g
10001, 21, 17, 11, h
10010, 22, 18, 12, i
10011, 23, 19, 13, j
10100, 24, 20, 14, k
10101, 25, 21, 15, l
10110, 26, 22, 16, m
10111, 27, 23, 17, n
11000, 30, 24, 18, 10
11001, 31, 25, 19, 11
11010, 32, 26, 1a, 12
11011, 33, 27, 1b, 13
11100, 34, 28, 1c, 14
11101, 35, 29, 1d, 15
11110, 36, 30, 1e, 16
11111, 37, 31, 1f, 17
100000, 40, 32, 20, 18
100001, 41, 33, 21, 19

[edit] Locomotive Basic

10 FOR i=1 TO 20
20 PRINT i,BIN$(i),HEX$(i)
30 NEXT

Output:

 1           1            1
 2           10           2
 3           11           3
 4           100          4
 5           101          5
 6           110          6
 7           111          7
 8           1000         8
 9           1001         9
 10          1010         A
 11          1011         B
 12          1100         C
 13          1101         D
 14          1110         E
 15          1111         F
 16          10000        10
 17          10001        11
 18          10010        12
 19          10011        13
 20          10100        14

[edit] Lua

for i = 1, 33 do
print( string.format( "%o \t %d \t %x", i, i, i ) )
end

[edit] Mathematica

Scan[Print[IntegerString[#, 2], ",", IntegerString[#, 8], 
",",#, ",",IntegerString[#, 16],",", IntegerString[#, 36]]&, Range[38]]

Output:

1,1,1,1,1
10,2,2,2,2
11,3,3,3,3
...
...
100010,42,34,22,y
100011,43,35,23,z
100100,44,36,24,10
100101,45,37,25,11
100110,46,38,26,12

[edit] MATLAB / Octave

fprintf('%3d  %3o  %3x\n',repmat(1:20,3,1))

Output:

  1    1    1
  2    2    2
  3    3    3
  4    4    4
  5    5    5
  6    6    6
  7    7    7
  8   10    8
  9   11    9
 10   12    a
 11   13    b
 12   14    c
 13   15    d
 14   16    e
 15   17    f
 16   20   10
 17   21   11
 18   22   12
 19   23   13
 20   24   14

[edit] Modula-3

MODULE Conv EXPORTS Main;
 
IMPORT IO, Fmt;
 
BEGIN
FOR i := 1 TO 33 DO
IO.Put(Fmt.Int(i, base := 10) & " ");
IO.Put(Fmt.Int(i, base := 16) & " ");
IO.Put(Fmt.Int(i, base := 8) & " ");
IO.Put("\n");
END;
END Conv.

Output:

1 1 1 
2 2 2 
3 3 3 
4 4 4 
5 5 5 
6 6 6 
7 7 7 
8 8 10 
9 9 11 
10 a 12 
11 b 13 
12 c 14 
13 d 15 
14 e 16 
15 f 17 
16 10 20 
17 11 21 
18 12 22 
19 13 23 
20 14 24 
21 15 25 
22 16 26 
23 17 27 
24 18 30 
25 19 31 
26 1a 32 
27 1b 33 
28 1c 34 
29 1d 35 
30 1e 36 
31 1f 37 
32 20 40 
33 21 41

[edit] NetRexx

/* NetRexx */
options replace format comments java crossref symbols nobinary
 
import java.util.Formatter
 
loop i_ = 1 to 3
loop n_ = 20 to 20000 by 2131
select case i_
when 1 then say useBif(n_)
when 2 then say useJavaFormat(n_)
when 3 then say useJavaNumber(n_)
otherwise nop
end
end n_
say
end i_
 
return
 
-- NetRexx doesn't have a decimal to octal conversion
method useBif(n_) public static
d_ = '_'
return '[Base 16='n_.d2x().right(8)',Base 10='n_.right(8)',Base 8='d_.right(8)',Base 2='n_.d2x().x2b().right(20)']'
 
-- Some of Java's java.lang.Number classes have conversion methods
method useJavaNumber(n_) public static
nx = Long.toHexString(n_)
nd = Long.toString(n_)
no = Long.toOctalString(n_)
nb = Long.toBinaryString(n_)
return '[Base 16='Rexx(nx).right(8)',Base 10='Rexx(nd).right(8)',Base 8='Rexx(no).right(8)',Base 2='Rexx(nb).right(20)']'
 
-- Java Formatter doesn't have a decimal to binary conversion
method useJavaFormat(n_) public static
fb = StringBuilder()
fm = Formatter(fb)
fm.format("[Base 16=%1$8x,Base 10=%1$8d,Base 8=%1$8o,Base 2=%2$20s]", [Object Long(n_), String('_')])
return fb.toString()
 

Output:

[Base 16=      14,Base 10=      20,Base 8=       _,Base 2=            00010100]
[Base 16=     867,Base 10=    2151,Base 8=       _,Base 2=        100001100111]
[Base 16=    10BA,Base 10=    4282,Base 8=       _,Base 2=    0001000010111010]
[Base 16=    190D,Base 10=    6413,Base 8=       _,Base 2=    0001100100001101]
[Base 16=    2160,Base 10=    8544,Base 8=       _,Base 2=    0010000101100000]
[Base 16=    29B3,Base 10=   10675,Base 8=       _,Base 2=    0010100110110011]
[Base 16=    3206,Base 10=   12806,Base 8=       _,Base 2=    0011001000000110]
[Base 16=    3A59,Base 10=   14937,Base 8=       _,Base 2=    0011101001011001]
[Base 16=    42AC,Base 10=   17068,Base 8=       _,Base 2=    0100001010101100]
[Base 16=    4AFF,Base 10=   19199,Base 8=       _,Base 2=    0100101011111111]

[Base 16=      14,Base 10=      20,Base 8=      24,Base 2=                   _]
[Base 16=     867,Base 10=    2151,Base 8=    4147,Base 2=                   _]
[Base 16=    10ba,Base 10=    4282,Base 8=   10272,Base 2=                   _]
[Base 16=    190d,Base 10=    6413,Base 8=   14415,Base 2=                   _]
[Base 16=    2160,Base 10=    8544,Base 8=   20540,Base 2=                   _]
[Base 16=    29b3,Base 10=   10675,Base 8=   24663,Base 2=                   _]
[Base 16=    3206,Base 10=   12806,Base 8=   31006,Base 2=                   _]
[Base 16=    3a59,Base 10=   14937,Base 8=   35131,Base 2=                   _]
[Base 16=    42ac,Base 10=   17068,Base 8=   41254,Base 2=                   _]
[Base 16=    4aff,Base 10=   19199,Base 8=   45377,Base 2=                   _]

[Base 16=      14,Base 10=      20,Base 8=      24,Base 2=               10100]
[Base 16=     867,Base 10=    2151,Base 8=    4147,Base 2=        100001100111]
[Base 16=    10ba,Base 10=    4282,Base 8=   10272,Base 2=       1000010111010]
[Base 16=    190d,Base 10=    6413,Base 8=   14415,Base 2=       1100100001101]
[Base 16=    2160,Base 10=    8544,Base 8=   20540,Base 2=      10000101100000]
[Base 16=    29b3,Base 10=   10675,Base 8=   24663,Base 2=      10100110110011]
[Base 16=    3206,Base 10=   12806,Base 8=   31006,Base 2=      11001000000110]
[Base 16=    3a59,Base 10=   14937,Base 8=   35131,Base 2=      11101001011001]
[Base 16=    42ac,Base 10=   17068,Base 8=   41254,Base 2=     100001010101100]
[Base 16=    4aff,Base 10=   19199,Base 8=   45377,Base 2=     100101011111111]

[edit] Nimrod

import strutils
 
for i in 0..33:
echo toBin(i, 6)," ",toOct(i, 3)," ",align($i,2)," ",toHex(i,2)

Output:

000000 000  0 00
000001 001  1 01
000010 002  2 02
000011 003  3 03
000100 004  4 04
000101 005  5 05
000110 006  6 06
000111 007  7 07
001000 010  8 08
001001 011  9 09
001010 012 10 0A
001011 013 11 0B
001100 014 12 0C
001101 015 13 0D
001110 016 14 0E
001111 017 15 0F
010000 020 16 10
010001 021 17 11
010010 022 18 12
010011 023 19 13
010100 024 20 14
010101 025 21 15
010110 026 22 16
010111 027 23 17
011000 030 24 18
011001 031 25 19
011010 032 26 1A
011011 033 27 1B
011100 034 28 1C
011101 035 29 1D
011110 036 30 1E
011111 037 31 1F
100000 040 32 20
100001 041 33 21

[edit] OCaml

for n = 0 to 33 do
Printf.printf " %3o %2d %2X\n" n n n (* binary not supported *)
done

[edit] PARI/GP

The only bases supported by the language itself (as opposed to custom functions) are binary and decimal.

printbinary(n)={
n=binary(n);
for(i=1,#n,print1(n[i]))
};
printdecimal(n)={
print1(n)
};

[edit] Perl

foreach my $n (0..33) {
printf " %6b %3o %2d %2X\n", $n, $n, $n, $n;
}

[edit] Perl 6

for 0..33 -> $n {
printf " %6b %3o %2d %2X\n", $n xx 4;
}

[edit] PHP

<?php
foreach (range(0, 33) as $n) {
echo decbin($n), "\t", decoct($n), "\t", $n, "\t", dechex($n), "\n";
}
?>
<?php
foreach (range(0, 33) as $n) {
printf(" %6b %3o %2d %2X\n", $n, $n, $n, $n);
}
?>

[edit] PL/I

 
get list (n);
put skip list (n); /* Prints N in decimal */
put skip edit (n) (B); /* prints N as a bit string, N > 0 */
 

[edit] PicoLisp

(de printNumber (N Base)
(when (>= N Base)
(printNumber (/ N Base) Base) )
(let C (% N Base)
(and (> C 9) (inc 'C 39))
(prin (char (+ C `(char "0")))) ) )
 
(printNumber 26 16))
(prinl)
(printNumber 123456789012345678901234567890 36))
(prinl)

Output:

1a
byw97um9s91dlz68tsi

[edit] PowerShell

The .NET class Convert handles conversions in binary, octal, decimal and hexadecimal. Furthermore, format strings may be used for hexadecimal conversion.

foreach ($n in 0..33) {
"Base 2: " + [Convert]::ToString($n, 2)
"Base 8: " + [Convert]::ToString($n, 8)
"Base 10: " + $n
"Base 10: " + [Convert]::ToString($n, 10)
"Base 10: " + ("{0:D}" -f $n)
"Base 16: " + [Convert]::ToString($n, 16)
"Base 16: " + ("{0:X}" -f $n)
}

[edit] PureBasic

For i=105 To 115
Bin$=RSet(Bin(i),8,"0") ;- Convert to wanted type & pad with '0'
Hex$=RSet(Hex(i),4,"0")
Dec$=RSet(Str(i),3)
PrintN(Dec$+" decimal = %"+Bin$+" = $"+Hex$+".")
Next
105 decimal = %01101001 = $0069.
106 decimal = %01101010 = $006A.
107 decimal = %01101011 = $006B.
108 decimal = %01101100 = $006C.
109 decimal = %01101101 = $006D.
110 decimal = %01101110 = $006E.
111 decimal = %01101111 = $006F.
112 decimal = %01110000 = $0070.
113 decimal = %01110001 = $0071.
114 decimal = %01110010 = $0072.
115 decimal = %01110011 = $0073.

[edit] Python

Works with: Python version 2.6

Binary (b), Octal (o), Decimal (d), and Hexadecimal (X and x) are supported by the formatmethod of a string

>>> for n in range(34):
print " {0:6b} {1:3o} {2:2d} {3:2X}".format(n, n, n, n)
#The following would give the same output, and,
#due to the outer brackets, works with Python 3.0 too
#print ( " {n:6b} {n:3o} {n:2d} {n:2X}".format(n=n) )
 
 
0 0 0 0
1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
101 5 5 5
110 6 6 6
111 7 7 7
1000 10 8 8
1001 11 9 9
1010 12 10 A
1011 13 11 B
1100 14 12 C
1101 15 13 D
1110 16 14 E
1111 17 15 F
10000 20 16 10
10001 21 17 11
10010 22 18 12
10011 23 19 13
10100 24 20 14
10101 25 21 15
10110 26 22 16
10111 27 23 17
11000 30 24 18
11001 31 25 19
11010 32 26 1A
11011 33 27 1B
11100 34 28 1C
11101 35 29 1D
11110 36 30 1E
11111 37 31 1F
100000 40 32 20
100001 41 33 21
>>>
Works with: Python version 2.5

Octal (o), Decimal (d), and Hexadecimal (X and x), but not binary are supported by the string modulo operator, %:

for n in range(34):
print " %3o %2d %2X" % (n, n, n)

For each of these bases there is also a built-in function that will convert it to a string with the proper prefix appended, so that it is a valid Python expression:

n = 33
#Python 3.x:
print(bin(n), oct(n), n, hex(n)) # bin() only available in Python 3.x and 2.6
# output: 0b100001 0o41 33 0x21
 
#Python 2.x:
#print oct(n), n, hex(n)
# output: 041 33 0x21

[edit] R

Conversion to and from binary does not have built-in support.

# dec to oct
as.octmode(x)
# dec to hex
as.hexmode(x)
# oct or hex to dec
as.integer(x)
# or
as.numeric(x)

[edit] Racket

 
#lang racket
 
;; Explicit conversion of numbers can use the standard radices
(map (λ(r) (number->string 123 r)) '(2 8 10 16))
;; -> '("1111011" "173" "123" "7b")
 
;; There is also the `~r' formatting function that works with any radix
;; up to 36
(for/list ([r (in-range 2 37)]) (~r 123 #:base r))
;; -> '("1111011" "02111" "3231" "344" "323" "432" "173" "641" "123" "201"
;; "3a" "69" "b8" "38" "7b" "47" "f6" "96" "36" "i5" "d5" "85" "35"
;; "n4" "j4" "f4" "b4" "74" "34" "u3" "r3" "o3" "l3" "i3" "f3")
 

[edit] REXX

[edit] dec ◄──► bin, hex

Note that some REXX interpreters have the D2B (decimal-->binary) built-in function.
So, the D2B function was coded here for those REXX interpreters that don't have that function.

The reason for the apparent complexity of the D2B function is to handle the special case of
zero   (with regards to striping leading zeroes from the converted number)..

/*REXX pgm shows REXX's ability to show decimal numbers in binary & hex.*/
 
do j=0 to 50 /*show some low-value num conversions*/
say right(j,3) ' in decimal is',
right(d2b(j),12) " in binary",
right(d2x(j),12) ' in hexadecimal.'
end /*j*/
exit /*stick a fork in it, we're done.*/
/*────────────────────────────D2B subroutine────────────────────────────*/
d2b: return word(strip(x2b(d2x(arg(1))),'L',0) 0,1) /*convert dec──►bin*/

output

  0  in decimal is            0  in binary            0  in hexadecimal.
  1  in decimal is            1  in binary            1  in hexadecimal.
  2  in decimal is           10  in binary            2  in hexadecimal.
  3  in decimal is           11  in binary            3  in hexadecimal.
  4  in decimal is          100  in binary            4  in hexadecimal.
  5  in decimal is          101  in binary            5  in hexadecimal.
  6  in decimal is          110  in binary            6  in hexadecimal.
  7  in decimal is          111  in binary            7  in hexadecimal.
  8  in decimal is         1000  in binary            8  in hexadecimal.
  9  in decimal is         1001  in binary            9  in hexadecimal.
 10  in decimal is         1010  in binary            A  in hexadecimal.
 11  in decimal is         1011  in binary            B  in hexadecimal.
 12  in decimal is         1100  in binary            C  in hexadecimal.
 13  in decimal is         1101  in binary            D  in hexadecimal.
 14  in decimal is         1110  in binary            E  in hexadecimal.
 15  in decimal is         1111  in binary            F  in hexadecimal.
 16  in decimal is        10000  in binary           10  in hexadecimal.
 17  in decimal is        10001  in binary           11  in hexadecimal.
 18  in decimal is        10010  in binary           12  in hexadecimal.
 19  in decimal is        10011  in binary           13  in hexadecimal.
 20  in decimal is        10100  in binary           14  in hexadecimal.
 21  in decimal is        10101  in binary           15  in hexadecimal.
 22  in decimal is        10110  in binary           16  in hexadecimal.
 23  in decimal is        10111  in binary           17  in hexadecimal.
 24  in decimal is        11000  in binary           18  in hexadecimal.
 25  in decimal is        11001  in binary           19  in hexadecimal.
 26  in decimal is        11010  in binary           1A  in hexadecimal.
 27  in decimal is        11011  in binary           1B  in hexadecimal.
 28  in decimal is        11100  in binary           1C  in hexadecimal.
 29  in decimal is        11101  in binary           1D  in hexadecimal.
 30  in decimal is        11110  in binary           1E  in hexadecimal.
 31  in decimal is        11111  in binary           1F  in hexadecimal.
 32  in decimal is       100000  in binary           20  in hexadecimal.
 33  in decimal is       100001  in binary           21  in hexadecimal.
 34  in decimal is       100010  in binary           22  in hexadecimal.
 35  in decimal is       100011  in binary           23  in hexadecimal.
 36  in decimal is       100100  in binary           24  in hexadecimal.
 37  in decimal is       100101  in binary           25  in hexadecimal.
 38  in decimal is       100110  in binary           26  in hexadecimal.
 39  in decimal is       100111  in binary           27  in hexadecimal.
 40  in decimal is       101000  in binary           28  in hexadecimal.
 41  in decimal is       101001  in binary           29  in hexadecimal.
 42  in decimal is       101010  in binary           2A  in hexadecimal.
 43  in decimal is       101011  in binary           2B  in hexadecimal.
 44  in decimal is       101100  in binary           2C  in hexadecimal.
 45  in decimal is       101101  in binary           2D  in hexadecimal.
 46  in decimal is       101110  in binary           2E  in hexadecimal.
 47  in decimal is       101111  in binary           2F  in hexadecimal.
 48  in decimal is       110000  in binary           30  in hexadecimal.
 49  in decimal is       110001  in binary           31  in hexadecimal.
 50  in decimal is       110010  in binary           32  in hexadecimal. 

[edit] dec ◄──► bin, hex, char

Rexx also has the ability to use base 256 and uses the D2C and C2D function for this purpose.

Of course, using base 256 is hampered in ASCII machines in that some lower values are
interpreted by the operating system as control characters and therefore aren't displayed as their (true) glyph.

/*REXX program shows REXX's ability to show dec nums in bin/hex/base256.*/
 
do j=14 to 67 /*display some lower-value numbers. */
say right(j,3) ' in decimal is',
right(d2b(j),12) " in binary",
right(d2x(j),12) ' in hexadecimal',
right(d2c(j),12) ' in base256.'
end
exit /*stick a fork in it, we're done.*/
/*────────────────────────────D2B subroutine────────────────────────────*/
d2b: return word(strip(x2b(d2x(arg(1))),'L',0) 0,1) /*convert dec──►bin*/

output

 14  in decimal is         1110  in binary            E  in hexadecimal            ♫  in base256.
 15  in decimal is         1111  in binary            F  in hexadecimal            ☼  in base256.
 16  in decimal is        10000  in binary           10  in hexadecimal            ►  in base256.
 17  in decimal is        10001  in binary           11  in hexadecimal            ◄  in base256.
 18  in decimal is        10010  in binary           12  in hexadecimal            ↕  in base256.
 19  in decimal is        10011  in binary           13  in hexadecimal            ‼  in base256.
 20  in decimal is        10100  in binary           14  in hexadecimal            ¶  in base256.
 21  in decimal is        10101  in binary           15  in hexadecimal            §  in base256.
 22  in decimal is        10110  in binary           16  in hexadecimal            ▬  in base256.
 23  in decimal is        10111  in binary           17  in hexadecimal            ↨  in base256.
 24  in decimal is        11000  in binary           18  in hexadecimal            ↑  in base256.
 25  in decimal is        11001  in binary           19  in hexadecimal            ↓  in base256.
 26  in decimal is        11010  in binary           1A  in hexadecimal            →  in base256.
 27  in decimal is        11011  in binary           1B  in hexadecimal            ←  in base256.
 28  in decimal is        11100  in binary           1C  in hexadecimal            ∟  in base256.
 29  in decimal is        11101  in binary           1D  in hexadecimal            ↔  in base256.
 30  in decimal is        11110  in binary           1E  in hexadecimal            ▲  in base256.
 31  in decimal is        11111  in binary           1F  in hexadecimal            ▼  in base256.
 32  in decimal is       100000  in binary           20  in hexadecimal               in base256.
 33  in decimal is       100001  in binary           21  in hexadecimal            !  in base256.
 34  in decimal is       100010  in binary           22  in hexadecimal            "  in base256.
 35  in decimal is       100011  in binary           23  in hexadecimal            #  in base256.
 36  in decimal is       100100  in binary           24  in hexadecimal            $  in base256.
 37  in decimal is       100101  in binary           25  in hexadecimal            %  in base256.
 38  in decimal is       100110  in binary           26  in hexadecimal            &  in base256.
 39  in decimal is       100111  in binary           27  in hexadecimal            '  in base256.
 40  in decimal is       101000  in binary           28  in hexadecimal            (  in base256.
 41  in decimal is       101001  in binary           29  in hexadecimal            )  in base256.
 42  in decimal is       101010  in binary           2A  in hexadecimal            *  in base256.
 43  in decimal is       101011  in binary           2B  in hexadecimal            +  in base256.
 44  in decimal is       101100  in binary           2C  in hexadecimal            ,  in base256.
 45  in decimal is       101101  in binary           2D  in hexadecimal            -  in base256.
 46  in decimal is       101110  in binary           2E  in hexadecimal            .  in base256.
 47  in decimal is       101111  in binary           2F  in hexadecimal            /  in base256.
 48  in decimal is       110000  in binary           30  in hexadecimal            0  in base256.
 49  in decimal is       110001  in binary           31  in hexadecimal            1  in base256.
 50  in decimal is       110010  in binary           32  in hexadecimal            2  in base256.
 51  in decimal is       110011  in binary           33  in hexadecimal            3  in base256.
 52  in decimal is       110100  in binary           34  in hexadecimal            4  in base256.
 53  in decimal is       110101  in binary           35  in hexadecimal            5  in base256.
 54  in decimal is       110110  in binary           36  in hexadecimal            6  in base256.
 55  in decimal is       110111  in binary           37  in hexadecimal            7  in base256.
 56  in decimal is       111000  in binary           38  in hexadecimal            8  in base256.
 57  in decimal is       111001  in binary           39  in hexadecimal            9  in base256.
 58  in decimal is       111010  in binary           3A  in hexadecimal            :  in base256.
 59  in decimal is       111011  in binary           3B  in hexadecimal            ;  in base256.
 60  in decimal is       111100  in binary           3C  in hexadecimal            <  in base256.
 61  in decimal is       111101  in binary           3D  in hexadecimal            =  in base256.
 62  in decimal is       111110  in binary           3E  in hexadecimal            >  in base256.
 63  in decimal is       111111  in binary           3F  in hexadecimal            ?  in base256.
 64  in decimal is      1000000  in binary           40  in hexadecimal            @  in base256.
 65  in decimal is      1000001  in binary           41  in hexadecimal            A  in base256.
 66  in decimal is      1000010  in binary           42  in hexadecimal            B  in base256.
 67  in decimal is      1000011  in binary           43  in hexadecimal            C  in base256.

[edit] Ruby

for n in 0..33
puts " %6b %3o %2d %2X" % [n, n, n, n]
end
puts
[2,8,10,16,36].each {|i| puts " 100.to_s(#{i}) => #{100.to_s(i)}"}
Output:
     0   0  0  0
     1   1  1  1
    10   2  2  2
    11   3  3  3
   100   4  4  4
   101   5  5  5
   110   6  6  6
   111   7  7  7
  1000  10  8  8
  1001  11  9  9
  1010  12 10  A
  1011  13 11  B
  1100  14 12  C
  1101  15 13  D
  1110  16 14  E
  1111  17 15  F
 10000  20 16 10
 10001  21 17 11
 10010  22 18 12
 10011  23 19 13
 10100  24 20 14
 10101  25 21 15
 10110  26 22 16
 10111  27 23 17
 11000  30 24 18
 11001  31 25 19
 11010  32 26 1A
 11011  33 27 1B
 11100  34 28 1C
 11101  35 29 1D
 11110  36 30 1E
 11111  37 31 1F
100000  40 32 20
100001  41 33 21

100.to_s(2) => 1100100
100.to_s(8) => 144
100.to_s(10) => 100
100.to_s(16) => 64
100.to_s(36) => 2s

[edit] Scheme

(do ((i 0 (+ i 1)))
((>= i 33))
(display (number->string i 2)) ; binary
(display " ")
(display (number->string i 8)) ; octal
(display " ")
(display (number->string i 10)) ; decimal, the "10" is optional
(display " ")
(display (number->string i 16)) ; hex
(newline))

[edit] Smalltalk

Works with: GNU Smalltalk

The radix can be from 2 to 49 and its value is prepended to the string followed by "r".

1 to: 33 do: [ :i |
('%1 %2 %3' % { i printStringRadix: 8. i printStringRadix: 16. i printStringRadix: 2 })
printNl.
].

[edit] Seed7

The radix operator converts an integer number to a string. The conversion uses the numeral system with the given base. The base can be any integer value between 2 and 36. Digits greater than 9 are represented with lower case characers (10 is represented with a, etc.). The operator RADIX works just like radix, but uses upper case characters for digits greater than 9 (10 is represented with A, etc.). The lpad operator is used to pad the result of the radix operator at the left side. The padding is done with spaces.

$ include "seed7_05.s7i";
 
const proc: main is func
local
var integer: i is 0;
begin
for i range 1 to 33 do
writeln(i lpad 6 <&
i radix 8 lpad 6 <&
i radix 16 lpad 6);
end for;
end func;

[edit] Standard ML

let
fun loop i =
if i < 34 then (
print (Int.fmt StringCvt.BIN i ^ "\t"
^ Int.fmt StringCvt.OCT i ^ "\t"
^ Int.fmt StringCvt.DEC i ^ "\t"
^ Int.fmt StringCvt.HEX i ^ "\n");
loop (i+1)
) else ()
in
loop 0
end

[edit] Tcl

The format command supports conversions to octal, decimal, and hex:

for {set n 0} {$n <= 33} {incr n} {
puts [format " %3o %2d %2X" $n $n $n]
}

[edit] TI-89 BASIC

Bases 2, 10, and 16 are supported. The base is controlled by a global mode.

Local old
getMode("Base")→old
setMode("Base", "BIN")
Disp string(16)
setMode("Base", "HEX")
Disp string(16)
setMode("Base", "DEC")
Disp string(16)
setMode("Base", old)

Output:

0b10000
0h10
16

[edit] XPL0

include c:\cxpl\codes;
int N;
[N:= 2;
repeat HexOut(0, N); Text(0, " ");
IntOut(0, N); CrLf(0);
N:= N*N;
until N=0;
]

Output:

00000002  2
00000004  4
00000010  16
00000100  256
00010000  65536

[edit] zkl

"%.nB" formats a [unsigned] number in base n (2-36). So

const N=16;
var fmt=[2..N].pump(String,"%%5.%dB".fmt); // %5.2B%5.3B%5.4B%5.5B ...
foreach n in (17){fmt.fmt(n.pump(N,List,n.fp(n)).xplode()).println()}
Output:
    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0
    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1
   10    2    2    2    2    2    2    2    2    2    2    2    2    2    2
   11   10    3    3    3    3    3    3    3    3    3    3    3    3    3
  100   11   10    4    4    4    4    4    4    4    4    4    4    4    4
  101   12   11   10    5    5    5    5    5    5    5    5    5    5    5
  110   20   12   11   10    6    6    6    6    6    6    6    6    6    6
  111   21   13   12   11   10    7    7    7    7    7    7    7    7    7
 1000   22   20   13   12   11   10    8    8    8    8    8    8    8    8
 1001  100   21   14   13   12   11   10    9    9    9    9    9    9    9
 1010  101   22   20   14   13   12   11   10    a    a    a    a    a    a
 1011  102   23   21   15   14   13   12   11   10    b    b    b    b    b
 1100  110   30   22   20   15   14   13   12   11   10    c    c    c    c
 1101  111   31   23   21   16   15   14   13   12   11   10    d    d    d
 1110  112   32   24   22   20   16   15   14   13   12   11   10    e    e
 1111  120   33   30   23   21   17   16   15   14   13   12   11   10    f
10000  121  100   31   24   22   20   17   16   15   14   13   12   11   10
(100).toString(36) //-->"2s"

For binary, decimal and hex, you can also have [fixed, sorry Europe] separators:

"%,.2B".fmt(1234567) //-->"1|0010|1101|0110|1000|0111"
"%,d".fmt(1234567) //-->"1,234,567"
"%,x".fmt(1234567) //-->"12|d6|87"
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox