Non-decimal radices/Output

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.

Ada

<lang 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;</lang> 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#

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

<lang algol68>main:(

 FOR i TO 33 DO
   printf(($10r6d," "16r6d," "8r6dl$, BIN i, BIN i, BIN i))
 OD

)</lang> 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

AutoHotkey

contributed by Laszlo on the ahk forum <lang AutoHotkey>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

}</lang>

AWK

C's printf() is just exposed: <lang awk>$ awk '{printf("%d 0%o 0x%x\n",$1,$1,$1)}' 10 10 012 0xa 16 16 020 0x10 255 255 0377 0xff</lang>

C

<lang c>#include <stdio.h>

int main() {

 int i;

 for(i=1; i <= 33; i++)
   printf("%6d %6x %6o\n", i, i, i);

 return 0;

}</lang>

Binary conversion using %b is not standard.

C++

<lang cpp>#include <iostream>

1. 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;

}</lang>

Binary conversion is not standard.

Clojure

Clojure eschews duplicating functionality already present in Java when interop is sufficiently idiomatic: <lang lisp>(Integer/toBinaryString 25) ; returns "11001" (Integer/toOctalString 25)  ; returns "31" (Integer/toHexString 25)  ; returns "19"

(dotimes [i 20]

 (println (Integer/toHexString i)))</lang>

Common Lisp

<lang lisp>(loop for n from 0 to 33 do

 (format t " ~6B ~3O ~2D ~2X~%" n n n n))</lang>

D

<lang 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);

}</lang>

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

Tango Version

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

Library: Tango

<lang d>for (int i = 0; i < 35; i++)

   Stdout.formatln ("{:b8} {:o3} {} {:x2}", i, i, i, i);</lang>

E

<lang 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()

}</lang>

Euphoria

<lang euphoria>for i = 1 to 33 do

   printf(1,"%6d %6x %6o\n",{i,i,i})

end for</lang>

Factor

<lang factor>1234567 2 36 [a,b] [ >base print ] with each</lang>

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

Forth

Works with: GNU Forth

GNU Forth has convenience functions for printing an integer in decimal or hex, regardless of the current BASE. <lang forth>: main 34 1 do cr i dec. i hex. loop ; main ... 11 $B ...</lang> This is not standardized because such functions are very easy to define as needed: <lang forth>: base. ( n base -- ) base @ >r base ! . r> base ! ;

oct. ( n -- ) 8 base. ;

bin. ( n -- ) 2 base. ;</lang>

Fortran

Works with: Fortran version 90 and later

<lang fortran>do n = 1, 33

 write(*, "(b6, o4, i4, z4)") n, n, n, n

end do</lang>

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. <lang gema>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})</lang> 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.

Go

<lang go>package main

import (

   "fmt"
   "math/big"
   "strconv"

)

func main() {

   // package strconv:
   // Itoa is the most common int to string conversion. it is base 10 only.
   x := strconv.Itoa(13)
   fmt.Printf("%q\n", x)

   // FormatInt handles arbitrary bases from 2 to 36.
   x = strconv.FormatInt(1313, 19)
   fmt.Printf("%q\n", x)

   // package fmt:  allows direct conversion from integer
   // to string types for 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)

   // package big:  string conversion is base 10 only.
   fmt.Println(big.NewInt(13))

}</lang> Output:

"13"
"3c2"
1101
15
13
d
13

Haskell

<lang 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</lang>

alternately, without Text.Printf: <lang haskell>import Numeric

main :: IO () main = mapM_ f [0..33] where

 f :: Int -> IO ()
 f n = putStrLn $ " " ++ showOct n "" ++ " " ++ show n ++ " " ++ showHex n ""</lang>

HicEst

<lang HicEst>DO n = 1, 33

 WRITE(Format="b6.0, o4.0, i4.0, z4.0") n, n, n, n

ENDDO</lang>

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. <lang Icon>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</lang>

Library: Icon Programming Library

printf.icn provides printf, fprintf, and sprintf

Library: Unicon Code Library

Output:

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

J

J can natively break out numbers using a specific base

<lang j> 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</lang> 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:

<lang j> 8 #.inv 4009 7 6 5 1

  -.&' '": 8 #.inv 4009

7651</lang> J also includes some explicit support for hexadecimal numbers

<lang j> require 'convert'

  hfd 180097588

ABC1234</lang> (and a few other hexadecimal related mechanisms which are not relevant here.)

Java

<lang java5>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
  }

}</lang>

JavaScript

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

<lang javascript>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(', '));

}</lang>

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

Locomotive Basic

<lang locobasic>10 FOR i=1 TO 20 20 PRINT i,BIN$(i),HEX$(i) 30 NEXT</lang>

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

Lua

<lang lua>for i = 1, 33 do

   print( string.format( "%o \t %d \t %x", i, i, i ) )

end</lang>

Mathematica

<lang Mathematica>Scan[Print[IntegerString[#, 2], ",", IntegerString[#, 8], ",",#, ",",IntegerString[#, 16],",", IntegerString[#, 36]]&, Range[38]]</lang>

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

Modula-3

<lang modula3>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.</lang> 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

OCaml

<lang ocaml>for n = 0 to 33 do

 Printf.printf " %3o %2d %2X\n" n n n (* binary not supported *)

done</lang>

PARI/GP

The only bases supported by the language itself (as opposed to custom functions) are binary and decimal. <lang parigp>printbinary(n)={

 n=binary(n);
 for(i=1,#n,print1(n[i]))

}; printdecimal(n)={

 print1(n)

};</lang>

Perl

<lang perl>foreach my $n (0..33) {

 printf " %6b %3o %2d %2X\n", $n, $n, $n, $n;

}</lang>

Perl 6

<lang perl6>for 0..33 -> $n {

 printf " %6b %3o %2d %2X\n", $n xx 4;

}</lang>

PHP

<lang php><?php foreach (range(0, 33) as $n) {

 echo decbin($n), "\t", decoct($n), "\t", $n, "\t", dechex($n), "\n";

} ?></lang>

<lang php><?php foreach (range(0, 33) as $n) {

 printf(" %6b %3o %2d %2X\n", $n, $n, $n, $n);

} ?></lang>

PL/I

<lang 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 */ </lang>

PicoLisp

<lang 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)</lang> Output:

1a
byw97um9s91dlz68tsi

PowerShell

The .NET class Convert handles conversions in binary, octal, decimal and hexadecimal. Furthermore, format strings may be used for hexadecimal conversion. <lang powershell>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)

}</lang>

PureBasic

<lang 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</lang>

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.

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

<lang python>>>> 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

>>></lang>

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, %: <lang python>for n in range(34): print " %3o %2d %2X" % (n, n, n)</lang>

---

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: <lang python>n = 33

1. Python 3.x:

print(bin(n), oct(n), n, hex(n)) # bin() only available in Python 3.x and 2.6

1. output: 0b100001 0o41 33 0x21

1. Python 2.x:
2. print oct(n), n, hex(n)
3. output: 041 33 0x21</lang>

R

Conversion to and from binary does not have built-in support. <lang R># dec to oct as.octmode(x)

1. dec to hex

as.hexmode(x)

1. oct or hex to dec

as.integer(x)

1. or

as.numeric(x)</lang>

REXX

Note that some REXX interpreters have the D2B (decimal-->binary) built-in function.
The D2B function was coded here just in case. <lang rexx> /*REXX program shows REXX's ability to show decimal numbers in bin & 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),9)    ' in hexadecimal.'
     end

exit

/*────────────────────────────D2B subroutine────────────────────────────*/

                                  /*Note: some newer REXX interpreters */
                                  /*      have the  D2B  func built-in.*/

d2b: procedure; _=x2b(d2x(arg(1))) /*with this function, dec──>bin is OK*/

    if _=0 then return 0          /*handle special case of 0000 (zero).*/
    return strip(_,'L',0)         /*return answer with no leading 0's. */

</lang> 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. 

Ruby

<lang ruby>irb(main):001:0> for n in 0..33

irb(main):002:1> puts " %6b %3o %2d %2X" % [n, n, n, n] irb(main):003:1> end

     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

=> 0..33</lang>

Scheme

<lang 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))</lang>

Smalltalk

Works with: GNU Smalltalk

The radix can be from 2 to 49 and its value is prepended to the string followed by "r". <lang smalltalk>1 to: 33 do: [ :i |

 ('%1 %2 %3' % { i printStringRadix: 8. i printStringRadix: 16. i printStringRadix: 2 })
 printNl.

].</lang>

Seed7

The function str 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. <lang seed7>$ 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 <& str(i, 8) lpad 6 <& str(i, 16) lpad 6);
   end for;
 end func;</lang>

Standard ML

<lang sml>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</lang>

Tcl

The format command supports conversions to octal, decimal, and hex: <lang tcl>for {set n 0} {$n <= 33} {incr n} {

   puts [format " %3o %2d %2X" $n $n $n]

}</lang>

TI-89 BASIC

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

<lang ti89b>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)</lang>

Output:

<lang ti89b>0b10000 0h10</lang>

16