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
<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>
BBC BASIC
<lang bbcbasic> 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)</lang>
Output:
0 123456789 -987654321 ABCD FFFFFFFF
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>
- 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.
<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
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
<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>
printf.icn provides printf, fprintf, and sprintf
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
NetRexx
<lang 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()
</lang> 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]
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
Binary (b), Octal (o), Decimal (d), and Hexadecimal (X and x) are supported by the formatmethod of a string
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>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
- 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</lang>
R
Conversion to and from binary does not have built-in support. <lang R># dec to oct as.octmode(x)
- dec to hex
as.hexmode(x)
- oct or hex to dec
as.integer(x)
- or
as.numeric(x)</lang>
REXX
dec ◄──► bin
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.
<lang rexx>/*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*/</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.
dec ◄──► 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.
<lang rexx>/*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*/</lang> 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.
Ruby
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
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 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. <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 <&
i radix 8 lpad 6 <&
i radix 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 16</lang>
XPL0
<lang 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; ]</lang>
Output:
00000002 2 00000004 4 00000010 16 00000100 256 00010000 65536
- Programming Tasks
- Arithmetic operations
- Ada
- ALGOL 68
- AutoHotkey
- AWK
- BBC BASIC
- C
- C++
- Clojure
- Common Lisp
- D
- Tango
- E
- Euphoria
- Factor
- Forth
- Fortran
- Gema
- Go
- Haskell
- HicEst
- Icon
- Unicon
- Icon Programming Library
- Unicon Code Library
- J
- Java
- JavaScript
- Locomotive Basic
- Lua
- Mathematica
- Modula-3
- NetRexx
- OCaml
- PARI/GP
- Perl
- Perl 6
- PHP
- PL/I
- PicoLisp
- PowerShell
- PureBasic
- Python
- R
- REXX
- Ruby
- Scheme
- Smalltalk
- Seed7
- Standard ML
- Tcl
- TI-89 BASIC
- XPL0
- Radices