Non-decimal radices/Output: Difference between revisions
m
→{{header|Wren}}: Minor tidy
(Added F# information) |
m (→{{header|Wren}}: Minor tidy) |
||
(46 intermediate revisions by 24 users not shown) | |||
Line 13:
The reverse operation is [[Common number base parsing]].
<br><br>
=={{header|11l}}==
<syntaxhighlight lang="11l">V n = 33
print(bin(n)‘ ’String(n, radix' 8)‘ ’n‘ ’hex(n))</syntaxhighlight>
{{out}}
<pre>
100001 41 33 21
</pre>
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<syntaxhighlight lang="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</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Non-decimal_radices_output.png Screenshot from Atari 8-bit computer]
<pre>
(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
</pre>
=={{header|Ada}}==
<
with Ada.Text_IO; use Ada.Text_IO;
Line 26 ⟶ 69:
New_Line;
end loop;
end Test_Integer_Text_IO;</
Sample output:
<pre style="height:30ex;overflow:scroll">
Line 65 ⟶ 108:
=={{header|Aime}}==
<
o_byte('\n');
o_xinteger(5, 1000000);
o_byte('\n');
o_xinteger(2, 1000000);
o_byte('\n');</
=={{header|ALGOL 68}}==
Line 79 ⟶ 122:
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - printf has been removed}}
<
FOR i TO 33 DO
printf(($10r6d," "16r6d," "8r6dl$, BIN i, BIN i, BIN i))
OD
)</
Sample output:
<pre>
Line 119 ⟶ 162:
000032 000020 000040
000033 000021 000041
</pre>
=={{header|ALGOL W}}==
Algol W has a standard procedure intbase16 that returns its parameter converted to a string in hexadecimal.
<syntaxhighlight lang="algolw">begin
% print some numbers in hex %
for i := 0 until 20 do write( intbase16( i ) )
end.</syntaxhighlight>
{{out}}
<pre>
00000000
00000001
00000002
00000003
00000004
00000005
00000006
00000007
00000008
00000009
0000000A
0000000B
0000000C
0000000D
0000000E
0000000F
00000010
00000011
00000012
00000013
00000014
</pre>
=={{header|AutoHotkey}}==
contributed by Laszlo on the ahk [http://www.autohotkey.com/forum/post-276235.html#276235 forum]
<
BC(NumStr,InputBase=8,OutputBase=10) {
Line 129 ⟶ 203:
DllCall("msvcrt\_i64toa","Int64",DllCall("msvcrt\_strtoui64","Str",NumStr,"Uint",0,"UInt",InputBase,"CDECLInt64"),"Str",S,"UInt",OutputBase,"CDECL")
Return S
}</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">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
]</syntaxhighlight>
{{out}}
<pre> 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</pre>
=={{header|AWK}}==
C's printf() is just exposed:
<
10
10 012 0xa
Line 139 ⟶ 260:
16 020 0x10
255
255 0377 0xff</
=={{header|BBC BASIC}}==
<
PRINT STR$(0)
PRINT STR$(123456789)
Line 149 ⟶ 270:
REM STR$~ converts to a hexadecimal string:
PRINT STR$~(43981)
PRINT STR$~(-1)</
'''Output:'''
<pre>
Line 162 ⟶ 283:
Variable <code>obase</code> is the base for all output. It can be 2 (binary) up to some implementation-dependent limit. In [[GNU bc]] the limit may be large, for example 2^31, with "digits" of bases bigger than 36 printed as individual decimal numbers.
{{works with|GNU bc}}
<syntaxhighlight lang="bc">
for(i=1;i<10;i++) {
obase=10; print i," "
Line 169 ⟶ 290:
obase=2; print i
print "\n"
}</
{{out}}
<pre>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</pre>
=={{header|C}}==
<
int main()
Line 183 ⟶ 314:
return 0;
}</
Binary conversion using <tt>%b</tt> is not standard.
=={{header|C sharp}}==
<
using System;
Line 209 ⟶ 340:
}
}
</syntaxhighlight>
{{out}}
<pre>
Line 260 ⟶ 391:
=={{header|C++}}==
<
#include <iomanip>
Line 271 ⟶ 402:
return 0;
}</
=={{header|Clojure}}==
Clojure eschews duplicating functionality already present in Java when interop is sufficiently idiomatic:
<
(Integer/toOctalString 25) ; returns "31"
(Integer/toHexString 25) ; returns "19"
(dotimes [i 20]
(println (Integer/toHexString i)))</
=={{header|Common Lisp}}==
<
(format t " ~6B ~3O ~2D ~2X~%" n n n n))</
=={{header|D}}==
<
void main() {
Line 294 ⟶ 425:
foreach (i; 0 .. 34)
writefln(" %6b %6o %6d %6x", i, i, i, i);
}</
{{out}}
<pre>Base: 2 8 10 16
Line 337 ⟶ 468:
{{libheader|Tango}}
<
Stdout.formatln ("{:b8} {:o3} {} {:x2}", i, i, i, i);</
=={{header|Dc}}==
<syntaxhighlight lang="dc">[ dn [ ]P ]sp
[
2o lpx
8o lpx
10o lpx
16o lpx
17o lpx
AP
1+ d21>b
]sb
1 lbx</syntaxhighlight>
Bases above 16 print blank separated "digits" (in decimal)
{{out}}
<pre>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</pre>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
Delphi has native support for decimal and hexadecimal output. There is much broader support for floating point output.
<syntaxhighlight lang="Delphi">
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;
</syntaxhighlight>
{{out}}
<pre>
Decimal Hexadecimal
-----------------------
123456789 - 075BCD15
</pre>
=={{header|E}}==
<
for base in [2, 8, 10, 12, 16, 36] {
def s := value.toString(base)
Line 347 ⟶ 539:
}
println()
}</
=={{header|Elixir}}==
<
{{out}}
Line 398 ⟶ 590:
=={{header|Euphoria}}==
<
printf(1,"%6d %6x %6o\n",{i,i,i})
end for</
=={{header|F_Sharp|F#}}==
<p>Base 8, 10 and 16 can be output by <code>printf</code></p>
<
ns |> Seq.iter (fun n -> printfn " %3o %2d %2X" n n n)</
{{out}}
<pre> 36 30 1E
Line 412 ⟶ 604:
41 33 21</pre>
<p>The .NET library <code>System.Convert</code> is able to also convert from and to base 2</p>
<
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]))</
{{out}}
<pre> 11110 36 30 1e
Line 425 ⟶ 617:
=={{header|Factor}}==
<
<pre style="height:30ex;overflow:scroll">
100101101011010000111
Line 467 ⟶ 659:
{{works with|GNU Forth}}
GNU Forth has convenience functions for printing an integer in decimal or hex, regardless of the current BASE.
<
main
...
11 $B
...</
This is not standardized because such functions are very easy to define as needed:
<
: oct. ( n -- ) 8 base. ;
: bin. ( n -- ) 2 base. ;</
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<
write(*, "(b6, o4, i4, z4)") n, n, n, n
end do</
=={{header|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:
<syntaxhighlight lang="freebasic">' 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</syntaxhighlight>
{{out}}
<pre>
Decimal Hex Octal Binary
======= ======== ======= ======
10 A 12 1010
26 1A 32 11010
52 34 64 110100
100 64 144 1100100
</pre>
=={{header|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.
<
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
<pre>$ gema -p radix.gema
The 99 beers and 0x2D Scotches.
The 99 (0x63, 0143) beers and 0x2D (45, 055) Scotches.</pre>
=={{header|Go}}==
<
import (
Line 517 ⟶ 734:
// There no equivalent for big ints.
fmt.Println(strconv.FormatInt(1313, 19))
}</
{{out}}
<pre>
Line 532 ⟶ 749:
=={{header|Haskell}}==
<
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 <code>Text.Printf</code>:
<
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:
<syntaxhighlight lang="haskell">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))</syntaxhighlight>
{{Out}}
<pre> 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</pre>
=={{header|HicEst}}==
<
WRITE(Format="b6.0, o4.0, i4.0, z4.0") n, n, n, n
ENDDO</
=={{header|Icon}} and {{header|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.
<
write("Non-decimal radices/Output")
every i := 255 | 2 | 5 | 16 do {
Line 563 ⟶ 858:
printf("%%i = %i\n",i) # image format
}
end</
{{libheader|Icon Programming Library}}
Line 580 ⟶ 875:
J can natively break out numbers using a specific base
<
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:
<
7 6 5 1
-.&' '": 8 #.inv 4009
7651</
J also includes some explicit support for hexadecimal numbers
<
hfd 180097588
ABC1234</
(and a few other hexadecimal related mechanisms which are not relevant here.)
=={{header|Java}}==
<
for(int a= 0;a < 33;a++){
System.out.println(Integer.toBinaryString(a));
Line 610 ⟶ 905:
System.out.printf("%3o %2d %2x\n",a ,a ,a); //printf like the other languages; binary not supported
}
}</
=={{header|JavaScript}}==
The <code><i>number</i>.toString(<i>radix</i>)</code> method produces a string representation of a number in any radix between 2 and 36.
<
for (var n = 0; n <= 33; n++) {
var row = [];
Line 621 ⟶ 916:
row.push( n.toString(bases[i]) );
print(row.join(', '));
}</
outputs
Line 660 ⟶ 955:
=={{header|Julia}}==
<syntaxhighlight lang="julia">using Primes, Printf
println("Primes
for i in primes(
end
</syntaxhighlight>{{out}}
<pre>
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
</pre>
=={{header|Klingphix}}==
<syntaxhighlight lang="klingphix">include ..\Utilitys.tlhy
33 [
( "decimal: " swap " bin: " over 8 itob reverse ) lprint nl
] for
"End " input</syntaxhighlight>
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// 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()
}
}</syntaxhighlight>
{{out}}
<pre>
2 8 10 16 19 36
------------------------------------
0
1
10
11
100
101
1000
1001
1010
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
</pre>
=={{header|Locomotive Basic}}==
<
20 PRINT i,BIN$(i),HEX$(i)
30 NEXT</
Output:
Line 720 ⟶ 1,078:
=={{header|Lua}}==
<
print( string.format( "%o \t %d \t %x", i, i, i ) )
end</
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang
{{out}}
<pre>1 1 1 1
10 2 2 2
11 3 3 3
100 4 4 4
...
100010 42 22 y
100011
100100 44 24 10
100101 45 25 11
100110 46 26 12
</pre>
=={{header|MATLAB}} / {{header|Octave}}==
<
Output:
<pre> 1 1 1
Line 767 ⟶ 1,130:
=={{header|Modula-3}}==
<
IMPORT IO, Fmt;
Line 778 ⟶ 1,141:
IO.Put("\n");
END;
END Conv.</
Output:
<pre style="height:30ex;overflow:scroll">
Line 817 ⟶ 1,180:
=={{header|NetRexx}}==
<
options replace format comments java crossref symbols nobinary
Line 855 ⟶ 1,218:
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()
</syntaxhighlight>
'''Output:'''
<pre style="height:30ex; overflow:scroll;">
Line 893 ⟶ 1,256:
=={{header|Nim}}==
<
for i in 0..33:
echo toBin(i, 6)," ",toOct(i, 3)," ",align($i,2)," ",toHex(i,2)</
Output:
<pre>000000 000 0 00
Line 934 ⟶ 1,297:
=={{header|OCaml}}==
<
Printf.printf " %3o %2d %2X\n" n n n (* binary not supported *)
done</
=={{header|PARI/GP}}==
The only bases supported by the language itself (as opposed to custom functions) are binary and decimal.
<
n=binary(n);
for(i=1,#n,print1(n[i]))
Line 946 ⟶ 1,309:
printdecimal(n)={
print1(n)
};</
=={{header|Perl}}==
<
printf " %6b %3o %2d %2X\n", $n, $n, $n, $n;
}</
=={{header|
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #000000;">32</span> <span style="color: #008080;">by</span> <span style="color: #000000;">10</span> <span style="color: #008080;">do</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"decimal:%3d hex:%3x octal:%3o binary:%7b\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
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
</pre>
=={{header|Phixmonti}}==
<syntaxhighlight lang="phixmonti">33 for
dup "decimal: " print print " bin: " print 8 int>bit print nl
endfor</syntaxhighlight>
=={{header|PHP}}==
<
foreach (range(0, 33) as $n) {
echo decbin($n), "\t", decoct($n), "\t", $n, "\t", dechex($n), "\n";
}
?></
<
foreach (range(0, 33) as $n) {
printf(" %6b %3o %2d %2X\n", $n, $n, $n, $n);
}
?></
=={{header|PicoLisp}}==
<
(when (>= N Base)
(printNumber (/ N Base) Base) )
Line 997 ⟶ 1,360:
(prinl)
(printNumber 123456789012345678901234567890 36))
(prinl)</
Output:
<pre>1a
Line 1,003 ⟶ 1,366:
=={{header|PL/I}}==
<syntaxhighlight 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 */
</syntaxhighlight>
=={{header|PowerShell}}==
The .NET class <code>Convert</code> handles conversions in binary, octal, decimal and hexadecimal. Furthermore, format strings may be used for hexadecimal conversion.
<
"Base 2: " + [Convert]::ToString($n, 2)
"Base 8: " + [Convert]::ToString($n, 8)
Line 1,019 ⟶ 1,382:
"Base 16: " + [Convert]::ToString($n, 16)
"Base 16: " + ("{0:X}" -f $n)
}</
=={{header|PureBasic}}==
<
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.
Line 1,044 ⟶ 1,407:
{{works with|Python|2.6}}
Binary (b), Octal (o), Decimal (d), and Hexadecimal (X and x) are supported by the [http://www.python.org/dev/peps/pep-3101/ format]method of a string
<div style="height:30ex;overflow:scroll"><
0 0 0 0
1 1 1 1
Line 1,085 ⟶ 1,448:
100000 40 32 20
100001 41 33 21
>>></
{{works with|Python|2.5}}
Octal (o), Decimal (d), and Hexadecimal (X and x), but not binary are supported by the string modulo operator, %:
<
----
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:
<
#Python 3.x:
print(bin(n), oct(n), n, hex(n)) # bin() only available in Python 3.x and 2.6
Line 1,101 ⟶ 1,464:
#Python 2.x:
#print oct(n), n, hex(n)
# output: 041 33 0x21</
=={{header|Quackery}}==
<syntaxhighlight lang="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 ]</syntaxhighlight>
{{out}}
<pre>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
</pre>
=={{header|R}}==
Conversion to and from binary does not have built-in support.
<
as.octmode(x)
# dec to hex
Line 1,112 ⟶ 1,515:
as.integer(x)
# or
as.numeric(x)</
=={{header|Racket}}==
<
#lang racket
Line 1,129 ⟶ 1,532:
;; "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")
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
Calling the <code>.base</code> method on a number returns a string. It can handle all bases between 2 and 36:
<syntaxhighlight lang="raku" line>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"</syntaxhighlight>
Alternatively, <code>printf</code> can be used for some common number bases:
<syntaxhighlight lang="raku" line>for 0..33 -> $n {
printf " %6b %3o %2d %2X\n", $n xx 4;
}</syntaxhighlight>
=={{header|REXX}}==
Line 1,137 ⟶ 1,556:
<br><br>The reason for the apparent complexity of the '''D2B''' function is to handle the special case of
<br>zero (with regards to striping leading zeroes from the converted number)..
<
do j=0 to 50 /*show some low-value num conversions*/
Line 1,146 ⟶ 1,565:
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'''
<pre style="height:20ex">
Line 1,206 ⟶ 1,625:
<br><br>Of course, using base 256 is hampered in ASCII machines in that some lower values are
<br>interpreted by the operating system as control characters and therefore aren't displayed as their (true) glyph.
<
do j=14 to 67 /*display some lower-value numbers. */
Line 1,216 ⟶ 1,635:
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'''
<pre style="height:20ex">
Line 1,273 ⟶ 1,692:
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.
</pre>
=={{header|Ring}}==
<syntaxhighlight lang="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)) + nl
</syntaxhighlight>
Output:
<pre>
0
123456789
-987654321
ABCD
FFFFFFFF
</pre>
=={{header|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 <code>BIN</code>, <code>OCT</code>, <code>DEC</code> or <code>HEX</code> 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 +
{{out}}
<pre>
1: "# 100111010b # 472o # 314d # 13Ah"
</pre>
=={{header|Ruby}}==
<
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)}"}</
{{out}}
<div style="height:30ex;overflow:scroll">
Line 1,324 ⟶ 1,774:
100.to_s(36) => 2s
</div>
=={{header|Rust}}==
<syntaxhighlight lang="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);
}</syntaxhighlight>
=={{header|Run BASIC}}==
<syntaxhighlight lang="runbasic">
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 decimal
</syntaxhighlight>
=={{header|Scala}}==
<syntaxhighlight lang="scala">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")
}</syntaxhighlight>
=={{header|Scheme}}==
<
((>= i 33))
(display (number->string i 2)) ; binary
Line 1,335 ⟶ 1,820:
(display " ")
(display (number->string i 16)) ; hex
(newline))</
=={{header|Seed7}}==
Line 1,346 ⟶ 1,831:
The [http://seed7.sourceforge.net/libraries/string.htm#%28in_string%29lpad%28in_integer%29 lpad] operator
is used to pad the result of the ''radix'' operator at the left side. The padding is done with spaces.
<
const proc: main is func
Line 1,357 ⟶ 1,842:
i radix 16 lpad 6);
end for;
end func;</
=={{header|Sidef}}==
<
printf(" %6b %3o %2d %2X\n", ([n]*4)...);
}</
=={{header|Smalltalk}}==
The radix can be from 2 to 49 and its value is prepended to the string followed by "r".
<
('%1 %2 %3' % { i printStringRadix: 8. i printStringRadix: 16. i printStringRadix: 2 })
printNl.
].</
=={{header|Standard ML}}==
<
fun loop i =
if i < 34 then (
Line 1,384 ⟶ 1,868:
in
loop 0
end</
=={{header|Tcl}}==
The <code>format</code> command supports conversions to octal, decimal, and hex:
<
puts [format " %3o %2d %2X" $n $n $n]
}</
<!--The following should be moved to: [[Number base conversion]]
Conversion to binary requires a procedure. Here's two ways to do it:
<
proc int2bits {i} {
string map {0 000 1 001 2 010 3 011 4 100 5 101 6 110 7 111} [format %o $i]
Line 1,405 ⟶ 1,889:
binary scan [binary format I1 $i] B* x
return $x
}</
-->
Line 1,413 ⟶ 1,897:
Bases 2, 10, and 16 are supported. The base is controlled by a global ''mode''.
<
getMode("Base")→old
setMode("Base", "BIN")
Line 1,421 ⟶ 1,905:
setMode("Base", "DEC")
Disp string(16)
setMode("Base", old)</
Output:
<
0h10
16</
=={{header|Wren}}==
{{libheader|Wren-fmt}}
Wren has no non-decimal number conversions in its standard library so this uses a module I wrote myself to reproduce the Haskell table.
<syntaxhighlight lang="wren">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)")
}</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|XPL0}}==
<
int N;
[N:= 2;
Line 1,437 ⟶ 1,978:
N:= N*N;
until N=0;
]</
Output:
Line 1,447 ⟶ 1,988:
00010000 65536
</pre>
=={{header|Yabasic}}==
<syntaxhighlight lang="yabasic">for i = 1 to 33
print "decimal: ", i, " hex: ", hex$(i), " bin: ", bin$(i)
next
</syntaxhighlight>
=={{header|zkl}}==
"%.nB" formats a [unsigned] number in base n (2-36). So
<
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()}</
{{out}}
<pre>
Line 1,473 ⟶ 2,020:
10000 121 100 31 24 22 20 17 16 15 14 13 12 11 10
</pre>
<
For binary, decimal and hex, you can also have [fixed, sorry Europe] separators:
<
"%,d".fmt(1234567) //-->"1,234,567"
"%,x".fmt(1234567) //-->"12|d6|87"</
|