Non-decimal radices/Output: Difference between revisions

 

 

 

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

 

New_Line;

end loop;

Sample output:

<pre style="height:30ex;overflow:scroll">

33 16#21# 8#41#

</pre>

=={{header|ALGOL 68}}==

{{trans|C}}

 

FOR i TO 33 DO

printf(($10r6d," "16r6d," "8r6dl$, BIN i, BIN i, BIN i))

OD

Sample output:

000001 000001 000001

000002 000002 000002

000033 000021 000041

</pre>

 

=={{header|AWK}}==

C's printf() is just exposed:

10

10 012 0xa

16 020 0x10

255

 

=={{header|C}}==

 

 

int main()

 

return 0;

 

Binary conversion using <tt>%b</tt> is not standard.

 

=={{header|C++}}==

 

#include <iomanip>

 

 

return 0;

 

 

=={{header|Common Lisp}}==

 

=={{header|D}}==

 

Number following formatting character is width. When no formatting

character is specified it is inferred from variable's type.

 

 

=={{header|E}}==

for base in [2, 8, 10, 12, 16, 36] {

def s := value.toString(base)

}

println()

 

=={{header|Forth}}==

{{works with|GNU Forth}}

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

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

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

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

 

=={{header|Haskell}}==

 

main :: IO ()

main = mapM_ f [0..33] where

f :: Int -> IO ()

 

=={{header|Java}}==

for(int a= 0;a < 33;a++){

System.out.println(Integer.toBinaryString(a));

System.out.printf("%3o %2d %2x\n",a ,a ,a); //printf like the other languages; binary not supported

}

 

=={{header|Modula-3}}==

 

IMPORT IO, Fmt;

IO.Put("\n");

END;

Output:

<pre style="height:30ex;overflow:scroll">

33 21 41

</pre>

 

=={{header|OCaml}}==

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

 

=={{header|Perl}}==

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

 

=={{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|Python}}==

{{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

 

0 0 0 0

1 1 1 1

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

#Python 2.x:

#print oct(n), n, hex(n)

 

=={{header|Ruby}}==

0 0 0 0

1 1 1 1

100000 40 32 20

100001 41 33 21

 

=={{header|Standard ML}}==

fun loop i =

if i < 34 then (

in

loop 0

 

=={{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]

binary scan [binary format I1 $i] B* x

return $x

 

-->