Non-decimal radices/Output
(Redirected from Common number base conversions)
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.
- Task
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.
11l
V n = 33
print(bin(n)‘ ’String(n, radix' 8)‘ ’n‘ ’hex(n))- Output:
100001 41 33 21
Action!
INCLUDE "D2:PRINTF.ACT" ;from the Action! Tool Kit
PROC Main()
CARD ARRAY v=[6502 1977 2021 256 1024 12345 9876 1111 0 16]
BYTE i,LMARGIN=$52,old
old=LMARGIN
LMARGIN=0 ;remove left margin on the screen
Put(125) PutE() ;clear the screen
FOR i=0 TO 9
DO
PrintF("(dec) %D = (hex) %H = (oct) %O%E",v(i),v(i),v(i))
OD
LMARGIN=old ;restore left margin on the screen
RETURN- Output:
Screenshot from Atari 8-bit computer
(dec) 6502 = (hex) 1966 = (oct) 14546 (dec) 1977 = (hex) 7B9 = (oct) 3671 (dec) 2021 = (hex) 7E5 = (oct) 3745 (dec) 256 = (hex) 100 = (oct) 400 (dec) 1024 = (hex) 400 = (oct) 2000 (dec) 12345 = (hex) 3039 = (oct) 30071 (dec) 9876 = (hex) 2694 = (oct) 23224 (dec) 1111 = (hex) 457 = (oct) 2127 (dec) 0 = (hex) 0 = (oct) 0 (dec) 16 = (hex) 10 = (oct) 20
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#
Aime
o_xinteger(16, 1000000);
o_byte('\n');
o_xinteger(5, 1000000);
o_byte('\n');
o_xinteger(2, 1000000);
o_byte('\n');ALGOL 68
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
ALGOL W
Algol W has a standard procedure intbase16 that returns its parameter converted to a string in hexadecimal.
begin
% print some numbers in hex %
for i := 0 until 20 do write( intbase16( i ) )
end.- Output:
00000000
00000001
00000002
00000003
00000004
00000005
00000006
00000007
00000008
00000009
0000000A
0000000B
0000000C
0000000D
0000000E
0000000F
00000010
00000011
00000012
00000013
00000014
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
}
Arturo
loop 0..33 'i ->
print [
pad as.binary i 6
pad as.octal i 2
pad to :string i 2
pad as.hex i 2
]
- 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
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
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
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.
for(i=1;i<10;i++) {
obase=10; print i," "
obase=8; print i," "
obase=3; print i," "
obase=2; print i
print "\n"
}
- Output:
1 1 1 1 2 2 2 10 3 3 10 11 4 4 11 100 5 5 12 101 6 6 20 110 7 7 21 111 8 10 22 1000 9 11 100 1001
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.
C#
using System;
namespace NonDecimalRadicesOutput
{
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 42; i++)
{
string binary = Convert.ToString(i, 2);
string octal = Convert.ToString(i, 8);
string hexadecimal = Convert.ToString(i, 16);
Console.WriteLine(string.Format("Decimal: {0}, Binary: {1}, Octal: {2}, Hexadecimal: {3}", i, binary, octal, hexadecimal));
}
Console.ReadKey();
}
}
}
- Output:
Decimal: 0, Binary: 0, Octal: 0, Hexadecimal: 0 Decimal: 1, Binary: 1, Octal: 1, Hexadecimal: 1 Decimal: 2, Binary: 10, Octal: 2, Hexadecimal: 2 Decimal: 3, Binary: 11, Octal: 3, Hexadecimal: 3 Decimal: 4, Binary: 100, Octal: 4, Hexadecimal: 4 Decimal: 5, Binary: 101, Octal: 5, Hexadecimal: 5 Decimal: 6, Binary: 110, Octal: 6, Hexadecimal: 6 Decimal: 7, Binary: 111, Octal: 7, Hexadecimal: 7 Decimal: 8, Binary: 1000, Octal: 10, Hexadecimal: 8 Decimal: 9, Binary: 1001, Octal: 11, Hexadecimal: 9 Decimal: 10, Binary: 1010, Octal: 12, Hexadecimal: a Decimal: 11, Binary: 1011, Octal: 13, Hexadecimal: b Decimal: 12, Binary: 1100, Octal: 14, Hexadecimal: c Decimal: 13, Binary: 1101, Octal: 15, Hexadecimal: d Decimal: 14, Binary: 1110, Octal: 16, Hexadecimal: e Decimal: 15, Binary: 1111, Octal: 17, Hexadecimal: f Decimal: 16, Binary: 10000, Octal: 20, Hexadecimal: 10 Decimal: 17, Binary: 10001, Octal: 21, Hexadecimal: 11 Decimal: 18, Binary: 10010, Octal: 22, Hexadecimal: 12 Decimal: 19, Binary: 10011, Octal: 23, Hexadecimal: 13 Decimal: 20, Binary: 10100, Octal: 24, Hexadecimal: 14 Decimal: 21, Binary: 10101, Octal: 25, Hexadecimal: 15 Decimal: 22, Binary: 10110, Octal: 26, Hexadecimal: 16 Decimal: 23, Binary: 10111, Octal: 27, Hexadecimal: 17 Decimal: 24, Binary: 11000, Octal: 30, Hexadecimal: 18 Decimal: 25, Binary: 11001, Octal: 31, Hexadecimal: 19 Decimal: 26, Binary: 11010, Octal: 32, Hexadecimal: 1a Decimal: 27, Binary: 11011, Octal: 33, Hexadecimal: 1b Decimal: 28, Binary: 11100, Octal: 34, Hexadecimal: 1c Decimal: 29, Binary: 11101, Octal: 35, Hexadecimal: 1d Decimal: 30, Binary: 11110, Octal: 36, Hexadecimal: 1e Decimal: 31, Binary: 11111, Octal: 37, Hexadecimal: 1f Decimal: 32, Binary: 100000, Octal: 40, Hexadecimal: 20 Decimal: 33, Binary: 100001, Octal: 41, Hexadecimal: 21 Decimal: 34, Binary: 100010, Octal: 42, Hexadecimal: 22 Decimal: 35, Binary: 100011, Octal: 43, Hexadecimal: 23 Decimal: 36, Binary: 100100, Octal: 44, Hexadecimal: 24 Decimal: 37, Binary: 100101, Octal: 45, Hexadecimal: 25 Decimal: 38, Binary: 100110, Octal: 46, Hexadecimal: 26 Decimal: 39, Binary: 100111, Octal: 47, Hexadecimal: 27 Decimal: 40, Binary: 101000, Octal: 50, Hexadecimal: 28 Decimal: 41, Binary: 101001, Octal: 51, Hexadecimal: 29
Binary conversion is not standard.
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;
}
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)))
Common Lisp
(loop for n from 0 to 33 do
(format t " ~6B ~3O ~2D ~2X~%" n n n n))
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
Tango Version
Number following formatting character is width. When no formatting character is specified it is inferred from variable's type.
for (int i = 0; i < 35; i++)
Stdout.formatln ("{:b8} {:o3} {} {:x2}", i, i, i, i);
Dc
[ dn [ ]P ]sp
[
2o lpx
8o lpx
10o lpx
16o lpx
17o lpx
AP
1+ d21>b
]sb
1 lbxBases above 16 print blank separated "digits" (in decimal)
- Output:
1 1 1 1 01 10 2 2 2 02 11 3 3 3 03 100 4 4 4 04 101 5 5 5 05 110 6 6 6 06 111 7 7 7 07 1000 10 8 8 08 1001 11 9 9 09 1010 12 10 A 10 1011 13 11 B 11 1100 14 12 C 12 1101 15 13 D 13 1110 16 14 E 14 1111 17 15 F 15 10000 20 16 10 16 10001 21 17 11 01 00 10010 22 18 12 01 01 10011 23 19 13 01 02 10100 24 20 14 01 03
Delphi
Delphi has native support for decimal and hexadecimal output. There is much broader support for floating point output.
procedure ShowRadixOutput(Memo: TMemo);
var I: integer;
begin
I:=123456789;
Memo.Lines.Add('Decimal Hexadecimal');
Memo.Lines.Add('-----------------------');
Memo.Lines.Add(IntToStr(I)+' - '+IntToHex(I,8));
end;
- Output:
Decimal Hexadecimal ----------------------- 123456789 - 075BCD15
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()
}Elixir
Enum.each(0..32, fn i -> :io.format "~2w :~6.2B, ~2.8B, ~2.16B~n", [i,i,i,i] end)
- Output:
0 : 0, 0, 0 1 : 1, 1, 1 2 : 10, 2, 2 3 : 11, 3, 3 4 : 100, 4, 4 5 : 101, 5, 5 6 : 110, 6, 6 7 : 111, 7, 7 8 : 1000, 10, 8 9 : 1001, 11, 9 10 : 1010, 12, A 11 : 1011, 13, B 12 : 1100, 14, C 13 : 1101, 15, D 14 : 1110, 16, E 15 : 1111, 17, F 16 : 10000, 20, 10 17 : 10001, 21, 11 18 : 10010, 22, 12 19 : 10011, 23, 13 20 : 10100, 24, 14 21 : 10101, 25, 15 22 : 10110, 26, 16 23 : 10111, 27, 17 24 : 11000, 30, 18 25 : 11001, 31, 19 26 : 11010, 32, 1A 27 : 11011, 33, 1B 28 : 11100, 34, 1C 29 : 11101, 35, 1D 30 : 11110, 36, 1E 31 : 11111, 37, 1F 32 :100000, 40, 20
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
Euphoria
for i = 1 to 33 do
printf(1,"%6d %6x %6o\n",{i,i,i})
end forF#
Base 8, 10 and 16 can be output by printf
let ns = [30..33]
ns |> Seq.iter (fun n -> printfn " %3o %2d %2X" n n n)
- Output:
36 30 1E 37 31 1F 40 32 20 41 33 21
The .NET library System.Convert is able to also convert from and to base 2
let bases = [2; 8; 10; 16]
ns |> Seq.map (fun n -> Seq.initInfinite (fun i -> n))
|> Seq.map (fun s -> Seq.zip s bases)
|> Seq.map (Seq.map System.Convert.ToString >> Seq.toList)
|> Seq.iter (fun s -> (printfn "%6s %2s %2s %2s" s.[0] s.[1] s.[2] s.[3]))
- Output:
11110 36 30 1e 11111 37 31 1f 100000 40 32 20 100001 41 33 21
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
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. ;
Fortran
do n = 1, 33
write(*, "(b6, o4, i4, z4)") n, n, n, n
end do
FreeBASIC
FreeBASIC has built in functions called Hex, Str, Oct and Bin which convert decimal numbers into hexadecimal, decimal, octal and binary strings respectively. Here's an example:
' FB 1.05.0 Win64
Dim ui(1 To 4) As UInteger = {10, 26, 52, 100}
Print "Decimal Hex Octal Binary"
Print "======= ======== ======= ======"
For i As Integer = 1 To 4
Print Str(ui(i)); Tab(12); Hex(ui(i)); Tab(23); Oct(ui(i)); Tab(31); Bin(ui(i))
Next
Sleep
- Output:
Decimal Hex Octal Binary ======= ======== ======= ====== 10 A 12 1010 26 1A 32 11010 52 34 64 110100 100 64 144 1100100
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.
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
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 ""
Or, generalising and tabulating a little:
import Data.List (unfoldr, transpose, intercalate)
import Data.Array (Array, listArray, (!))
import Data.Monoid ((<>))
-- ARBITRARY RADICES ---------------------------------------
bases :: [Int]
bases = abs <$> [2, 7, 8, 10, 12, 16, 32]
tableRows :: [[String]]
tableRows = ((([baseDigits] <*> bases) <*>) . return) <$> [1 .. 33]
digits :: Array Int Char
digits = listArray (0, 35) (['0' .. '9'] <> ['A' .. 'Z'])
baseDigits :: Int -> Int -> String
baseDigits base
| base > 36 = const "Needs glyphs beyond Z"
| otherwise = reverse . unfoldr remQuot
where
remQuot 0 = Nothing
remQuot n =
let (q, r) = quotRem n base
in Just (digits ! r, q)
-- TEST AND TABULATION-------------------------------------
table :: String -> [[String]] -> [String]
table delim rows =
intercalate delim <$>
transpose
((fmap =<< flip justifyRight ' ' . maximum . fmap length) <$> transpose rows)
justifyRight :: Int -> Char -> String -> String
justifyRight n c s = drop (length s) (replicate n c <> s)
main :: IO ()
main =
mapM_
putStrLn
(table " " (([fmap show, fmap $ const "----"] <*> [bases]) <> tableRows))
- Output:
2 7 8 10 12 16 32
---- ---- ---- ---- ---- ---- ----
1 1 1 1 1 1 1
10 2 2 2 2 2 2
11 3 3 3 3 3 3
100 4 4 4 4 4 4
101 5 5 5 5 5 5
110 6 6 6 6 6 6
111 10 7 7 7 7 7
1000 11 10 8 8 8 8
1001 12 11 9 9 9 9
1010 13 12 10 A A A
1011 14 13 11 B B B
1100 15 14 12 10 C C
1101 16 15 13 11 D D
1110 20 16 14 12 E E
1111 21 17 15 13 F F
10000 22 20 16 14 10 G
10001 23 21 17 15 11 H
10010 24 22 18 16 12 I
10011 25 23 19 17 13 J
10100 26 24 20 18 14 K
10101 30 25 21 19 15 L
10110 31 26 22 1A 16 M
10111 32 27 23 1B 17 N
11000 33 30 24 20 18 O
11001 34 31 25 21 19 P
11010 35 32 26 22 1A Q
11011 36 33 27 23 1B R
11100 40 34 28 24 1C S
11101 41 35 29 25 1D T
11110 42 36 30 26 1E U
11111 43 37 31 27 1F V
100000 44 40 32 28 20 10
100001 45 41 33 29 21 11
HicEst
DO n = 1, 33
WRITE(Format="b6.0, o4.0, i4.0, z4.0") n, n, n, n
ENDDOIcon 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.
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
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.)
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
}
}
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
Julia
using Primes, Printf
println("Primes ≤ $hi written in common bases.")
@printf("%8s%8s%8s%8s", "bin", "oct", "dec", "hex")
for i in primes(50)
@printf("%8s%8s%8s%8s\n", bin(i), oct(i), dec(i), hex(i))
end
- Output:
Primes ≤ 50 written in common bases.
bin oct dec hex
10 2 2 2
11 3 3 3
101 5 5 5
111 7 7 7
1011 13 11 b
1101 15 13 d
10001 21 17 11
10011 23 19 13
10111 27 23 17
11101 35 29 1d
11111 37 31 1f
100101 45 37 25
101001 51 41 29
101011 53 43 2b
101111 57 47 2f
Klingphix
include ..\Utilitys.tlhy
33 [
( "decimal: " swap " bin: " over 8 itob reverse ) lprint nl
] for
"End " inputKotlin
// version 1.1.2
fun main(args: Array<String>) {
val bases = intArrayOf(2, 8, 10, 16, 19, 36)
for (base in bases) print("%6s".format(base))
println()
println("-".repeat(6 * bases.size))
for (i in 0..35) {
for (base in bases) print("%6s".format(i.toString(base)))
println()
}
}
- Output:
2 8 10 16 19 36
------------------------------------
0 0 0 0 0 0
1 1 1 1 1 1
10 2 2 2 2 2
11 3 3 3 3 3
100 4 4 4 4 4
101 5 5 5 5 5
110 6 6 6 6 6
111 7 7 7 7 7
1000 10 8 8 8 8
1001 11 9 9 9 9
1010 12 10 a a a
1011 13 11 b b b
1100 14 12 c c c
1101 15 13 d d d
1110 16 14 e e e
1111 17 15 f f f
10000 20 16 10 g g
10001 21 17 11 h h
10010 22 18 12 i i
10011 23 19 13 10 j
10100 24 20 14 11 k
10101 25 21 15 12 l
10110 26 22 16 13 m
10111 27 23 17 14 n
11000 30 24 18 15 o
11001 31 25 19 16 p
11010 32 26 1a 17 q
11011 33 27 1b 18 r
11100 34 28 1c 19 s
11101 35 29 1d 1a t
11110 36 30 1e 1b u
11111 37 31 1f 1c v
100000 40 32 20 1d w
100001 41 33 21 1e x
100010 42 34 22 1f y
100011 43 35 23 1g z
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
Lua
for i = 1, 33 do
print( string.format( "%o \t %d \t %x", i, i, i ) )
end
Mathematica /Wolfram Language
Table[IntegerString[n,b], {n,Range@38}, {b,{2,8,16,36}}] // Grid
- Output:
1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
...
100010 42 22 y
100011 43 23 z
100100 44 24 10
100101 45 25 11
100110 46 26 12
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
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
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]
Nim
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
OCaml
for n = 0 to 33 do
Printf.printf " %3o %2d %2X\n" n n n (* binary not supported *)
done
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)
};Perl
foreach my $n (0..33) {
printf " %6b %3o %2d %2X\n", $n, $n, $n, $n;
}
Phix
with javascript_semantics for i=2 to 32 by 10 do printf(1,"decimal:%3d hex:%3x octal:%3o binary:%7b\n",i) end for
- Output:
decimal: 2 hex: 2 octal: 2 binary: 10 decimal: 12 hex: C octal: 14 binary: 1100 decimal: 22 hex: 16 octal: 26 binary: 10110 decimal: 32 hex: 20 octal: 40 binary: 100000
Phixmonti
33 for
dup "decimal: " print print " bin: " print 8 int>bit print nl
endforPHP
<?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);
}
?>
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
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 */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)
}
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.
Python
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
>>>
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
Quackery
' [ 22 333 4444 55555 ] witheach
[ dup
say "Decimal " echo cr
dup
' [ 2 3 4 5 ] witheach
[ 2dup say " in base " echo
swap base put
say " -> " echo cr
base release ]
cr 2drop ]- Output:
Decimal 22 in base 2 -> 10110 in base 3 -> 211 in base 4 -> 112 in base 5 -> 42 Decimal 333 in base 2 -> 101001101 in base 3 -> 110100 in base 4 -> 11031 in base 5 -> 2313 Decimal 4444 in base 2 -> 1000101011100 in base 3 -> 20002121 in base 4 -> 1011130 in base 5 -> 120234 Decimal 55555 in base 2 -> 1101100100000011 in base 3 -> 2211012121 in base 4 -> 31210003 in base 5 -> 3234210
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)
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")
Raku
(formerly Perl 6)
Calling the .base method on a number returns a string. It can handle all bases between 2 and 36:
say 30.base(2); # "11110"
say 30.base(8); # "36"
say 30.base(10); # "30"
say 30.base(16); # "1E"
say 30.base(30); # "10"
Alternatively, printf can be used for some common number bases:
for 0..33 -> $n {
printf " %6b %3o %2d %2X\n", $n xx 4;
}
REXX
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.
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.
Ring
# Project : Non Decimal radices/Output
see string(0) + nl
see string(123456789) + nl
see string(-987654321) + nl
see upper(hex(43981)) + nl
see upper(hex(-1)) + nlOutput:
0 123456789 -987654321 ABCD FFFFFFFF
RPL
Unsigned integers are displayed in binary, octal, decimal or hexadecimal base depending on the state of 2 user flags, which can be easily configured by using resp. the BIN, OCT, DEC or HEX instruction. It is not possible to display several numbers in different bases simultaneously, unless you "freeze" their appearance by converting them to a string:
#314 DUP BIN →STR " " + OVER OCT →STR + " " + OVER DEC →STR + " " + OVER HEX →STR +
- Output:
1: "# 100111010b # 472o # 314d # 13Ah"
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
Rust
fn main() {
// To render the number as string, use format! macro instead
println!("Binary: {:b}", 0xdeadbeefu32);
println!("Binary with 0b prefix: {:#b}", 0xdeadbeefu32);
println!("Octal: {:o}", 0xdeadbeefu32);
println!("Octal with 0o prefix: {:#o}", 0xdeadbeefu32);
println!("Decimal: {}", 0xdeadbeefu32);
println!("Lowercase hexadecimal: {:x}", 0xdeadbeefu32);
println!("Lowercase hexadecimal with 0x prefix: {:#x}", 0xdeadbeefu32);
println!("Uppercase hexadecimal: {:X}", 0xdeadbeefu32);
println!("Uppercase hexadecimal with 0x prefix: {:#X}", 0xdeadbeefu32);
}
Run BASIC
print asc("X") ' convert to ascii
print chr$(169) ' ascii to character
print dechex$(255) ' decimal to hex
print hexdec("FF") ' hex to decimal
print str$(467) ' decimal to string
print val("27") ' string to decimalScala
object Main extends App {
val radices = List(2, 8, 10, 16, 19, 36)
for (base <- radices) print(f"$base%6d")
println(s"""\n${"-" * (6 * radices.length)}""")
for (i <- BigInt(0) to 35; // BigInt has a toString(radix) method
radix <- radices;
eol = if (radix == radices.last) '\n' else '\0'
) print(f"${i.toString(radix)}%6s$eol")
}
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))
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;Sidef
range(0, 33).each { |n|
printf(" %6b %3o %2d %2X\n", ([n]*4)...);
}
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.
].
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
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]
}
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
16Wren
Wren has no non-decimal number conversions in its standard library so this uses a module I wrote myself to reproduce the Haskell table.
import "./fmt" for Conv, Fmt
System.print(" 2 7 8 10 12 16 32")
System.print("------ ---- ---- ---- ---- ---- ----")
for (i in 1..33) {
var b2 = Fmt.b(6, i)
var b7 = Fmt.s(4, Conv.itoa(i, 7))
var b8 = Fmt.o(4, i)
var b10 = Fmt.d(4, i)
var b12 = Fmt.s(4, Conv.Itoa(i, 12))
var b16 = Fmt.X(4, i)
var b32 = Fmt.s(4, Conv.Itoa(i, 32))
System.print("%(b2) %(b7) %(b8) %(b10) %(b12) %(b16) %(b32)")
}
- Output:
2 7 8 10 12 16 32
------ ---- ---- ---- ---- ---- ----
1 1 1 1 1 1 1
10 2 2 2 2 2 2
11 3 3 3 3 3 3
100 4 4 4 4 4 4
101 5 5 5 5 5 5
110 6 6 6 6 6 6
111 10 7 7 7 7 7
1000 11 10 8 8 8 8
1001 12 11 9 9 9 9
1010 13 12 10 A A A
1011 14 13 11 B B B
1100 15 14 12 10 C C
1101 16 15 13 11 D D
1110 20 16 14 12 E E
1111 21 17 15 13 F F
10000 22 20 16 14 10 G
10001 23 21 17 15 11 H
10010 24 22 18 16 12 I
10011 25 23 19 17 13 J
10100 26 24 20 18 14 K
10101 30 25 21 19 15 L
10110 31 26 22 1A 16 M
10111 32 27 23 1B 17 N
11000 33 30 24 20 18 O
11001 34 31 25 21 19 P
11010 35 32 26 22 1A Q
11011 36 33 27 23 1B R
11100 40 34 28 24 1C S
11101 41 35 29 25 1D T
11110 42 36 30 26 1E U
11111 43 37 31 27 1F V
100000 44 40 32 28 20 10
100001 45 41 33 29 21 11
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
Yabasic
for i = 1 to 33
print "decimal: ", i, " hex: ", hex$(i), " bin: ", bin$(i)
nextzkl
"%.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"Categories:
- Programming Tasks
- Arithmetic operations
- 11l
- Action!
- Action! Tool Kit
- Ada
- Aime
- ALGOL 68
- ALGOL W
- AutoHotkey
- Arturo
- AWK
- BBC BASIC
- Bc
- C
- C sharp
- C++
- Clojure
- Common Lisp
- D
- Tango
- Dc
- Delphi
- SysUtils,StdCtrls
- E
- Elixir
- Erlang
- Euphoria
- F Sharp
- Factor
- Forth
- Fortran
- FreeBASIC
- Gema
- Go
- Haskell
- HicEst
- Icon
- Unicon
- Icon Programming Library
- Unicon Code Library
- J
- Java
- JavaScript
- Julia
- Klingphix
- Kotlin
- Locomotive Basic
- Lua
- Mathematica
- Wolfram Language
- MATLAB
- Octave
- Modula-3
- NetRexx
- Nim
- OCaml
- PARI/GP
- Perl
- Phix
- Phixmonti
- PHP
- PicoLisp
- PL/I
- PowerShell
- PureBasic
- Python
- Quackery
- R
- Racket
- Raku
- REXX
- Ring
- RPL
- Ruby
- Rust
- Run BASIC
- Scala
- Scheme
- Seed7
- Sidef
- Smalltalk
- Standard ML
- Tcl
- TI-89 BASIC
- Wren
- Wren-fmt
- XPL0
- Yabasic
- Zkl
- Radices