Binary digits: Difference between revisions
PatGarrett (talk | contribs) m (→{{header|360 Assembly}}: Superfluous blanks suppressed) |
(Added an Algol W sample) |
||
Line 171: | Line 171: | ||
+9000 => TFFFTTFFTFTFFF |
+9000 => TFFFTTFFTFTFFF |
||
</pre> |
</pre> |
||
=={{header|ALGOL W}}== |
|||
<lang algolw>begin |
|||
% prints an integer in binary - the number must be greater than zero % |
|||
procedure printBinaryDigits( integer value n ) ; |
|||
begin |
|||
if n not = 0 then begin |
|||
printBinaryDigits( n div 2 ); |
|||
writeon( if n rem 2 = 1 then "1" else "0" ) |
|||
end |
|||
end binaryDigits ; |
|||
% prints an integer in binary - the number must not be negative % |
|||
procedure printBinary( integer value n ) ; |
|||
begin |
|||
if n = 0 then writeon( "0" ) |
|||
else printBinaryDigits( n ) |
|||
end printBinary ; |
|||
% test the printBinaryDigits procedure % |
|||
for i := 5, 50, 9000 do begin |
|||
write(); |
|||
printBinary( i ); |
|||
end |
|||
end.</lang> |
|||
=={{header|AutoHotkey}}== |
=={{header|AutoHotkey}}== |
Revision as of 09:00, 30 August 2015
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
The task is to output the sequence of binary digits for a given non-negative integer.
The decimal value 5, should produce an output of 101 The decimal value 50 should produce an output of 110010 The decimal value 9000 should produce an output of 10001100101000
The results can be achieved using builtin radix functions within the language, if these are available, or alternatively a user defined function can be used. The output produced should consist just of the binary digits of each number followed by a newline. There should be no other whitespace, radix or sign markers in the produced output, and leading zeros should not appear in the results.
0815
<lang 0815>}:r:|~ Read numbers in a loop.
}:b: Treat the queue as a stack and <:2:= accumulate the binary digits /=>&~ of the given number. ^:b: <:0:-> Enqueue negative 1 as a sentinel. { Dequeue the first binary digit. }:p: ~%={+ Rotate each binary digit into place and print it. ^:p: <:a:~$ Output a newline.
^:r:</lang>
- Output:
Note that 0815 reads numeric input in hexadecimal.
<lang bash>echo -e "5\n32\n2329" | 0815 bin.0 101 110010 10001100101001</lang>
360 Assembly
<lang 360asm>* Binary digits 27/08/2015 BINARY CSECT
USING BINARY,R12 LR R12,R15 set base register
BEGIN LA R10,4
LA R9,N
LOOPN MVC W,0(R9)
MVI FLAG,X'00' LA R8,32 LA R2,CBIN
LOOP TM W,B'10000000' test fist bit
BZ ZERO zero MVI FLAG,X'01' one written MVI 0(R2),C'1' write 1 B CONT
ZERO CLI FLAG,X'01' is one written ?
BNE BLANK MVI 0(R2),C'0' write 0 B CONT
BLANK BCTR R2,0 backspace CONT L R3,W
SLL R3,1 shilf left ST R3,W LA R2,1(R2) next bit BCT R8,LOOP loop on bits
PRINT CLI FLAG,X'00' is '0'
BNE NOTZERO MVI 0(R2),C'0' then write 0
NOTZERO L R1,0(R9)
XDECO R1,CDEC XPRNT CDEC,45 LA R9,4(R9) BCT R10,LOOPN loop on numbers
RETURN XR R15,R15 set return code
BR R14 return to caller
N DC F'0',F'5',F'50',F'9000' W DS F work FLAG DS X flag for trailing blanks CDEC DS CL12 decimal value
DC C' '
CBIN DC CL32' ' binary value
YREGS END BINARY</lang>
- Output:
0 0 5 101 50 110010 9000 10001100101000
ACL2
<lang Lisp>(include-book "arithmetic-3/top" :dir :system)
(defun bin-string-r (x)
(if (zp x) "" (string-append (bin-string-r (floor x 2)) (if (= 1 (mod x 2)) "1" "0"))))
(defun bin-string (x)
(if (zp x) "0" (bin-string-r x)))</lang>
Ada
<lang Ada>with Ada.Text_IO;
procedure Binary_Output is
package IIO is new Ada.Text_IO.Integer_IO(Integer);
function To_Binary(N: Natural) return String is S: String(1 .. 1000); -- more than plenty! Left: Positive := S'First; Right: Positive := S'Last; begin IIO.Put(To => S, Item => N, Base => 2); -- This is the conversion! -- Now S is a String with many spaces and some "2#...#" somewhere. -- We only need the "..." part without spaces or base markers. while S(Left) /= '#' loop Left := Left + 1; end loop; while S(Right) /= '#' loop Right := Right - 1; end loop; return S(Left+1 .. Right-1); end To_Binary;
begin
Ada.Text_IO.Put_Line(To_Binary(5)); -- 101 Ada.Text_IO.Put_Line(To_Binary(50)); -- 110010 Ada.Text_IO.Put_Line(To_Binary(9000)); -- 10001100101000
end Binary_Output;</lang>
Aime
<lang aime>o_xinteger(2, 0); o_byte('\n'); o_xinteger(2, 5); o_byte('\n'); o_xinteger(2, 50); o_byte('\n'); o_form("/x2/\n", 9000);</lang>
- Output:
0 101 110010 10001100101000
ALGOL 68
File: Binary_digits.a68<lang algol68>#!/usr/local/bin/a68g --script #
printf((
$g" => "2r3d l$, 5, BIN 5, $g" => "2r6d l$, 50, BIN 50, $g" => "2r14d l$, 9000, BIN 9000
));
- or coerce to an array of BOOL #
print((
5, " => ", []BOOL(BIN 5)[bits width-3+1:], new line, 50, " => ", []BOOL(BIN 50)[bits width-6+1:], new line, 9000, " => ", []BOOL(BIN 9000)[bits width-14+1:], new line
))</lang>
- Output
+5 => 101 +50 => 110010 +9000 => 10001100101000 +5 => TFT +50 => TTFFTF +9000 => TFFFTTFFTFTFFF
ALGOL W
<lang algolw>begin
% prints an integer in binary - the number must be greater than zero % procedure printBinaryDigits( integer value n ) ; begin if n not = 0 then begin printBinaryDigits( n div 2 ); writeon( if n rem 2 = 1 then "1" else "0" ) end end binaryDigits ;
% prints an integer in binary - the number must not be negative % procedure printBinary( integer value n ) ; begin if n = 0 then writeon( "0" ) else printBinaryDigits( n ) end printBinary ;
% test the printBinaryDigits procedure % for i := 5, 50, 9000 do begin write(); printBinary( i ); end
end.</lang>
AutoHotkey
<lang AutoHotkey>MsgBox % NumberToBinary(5) ;101 MsgBox % NumberToBinary(50) ;110010 MsgBox % NumberToBinary(9000) ;10001100101000
NumberToBinary(InputNumber) {
While, InputNumber Result := (InputNumber & 1) . Result, InputNumber >>= 1 Return, Result
}</lang>
AutoIt
<lang autoit> ConsoleWrite(IntToBin(50) & @CRLF)
Func IntToBin($iInt) $Stack = ObjCreate("System.Collections.Stack") Local $b = -1, $r = "" While $iInt <> 0 $b = Mod($iInt, 2) $iInt = INT($iInt/2) $Stack.Push ($b) WEnd For $i = 1 TO $Stack.Count $r &= $Stack.Pop Next Return $r EndFunc ;==>IntToBin </lang>
AWK
<lang awk>BEGIN {
print tobinary(5) print tobinary(50) print tobinary(9000)
}
function tobinary(num) {
outstr = "" l = num while ( l ) { if ( l%2 == 0 ) { outstr = "0" outstr } else { outstr = "1" outstr } l = int(l/2) } # Make sure we output a zero for a value of zero if ( outstr == "" ) { outstr = "0" } return outstr
}</lang>
Axe
This example builds a string backwards to ensure the digits are displayed in the correct order. It uses bitwise logic to extract one bit at a time. <lang axe>Lbl BIN .Axe supports 16-bit integers, so 16 digits are enough L₁+16→P 0→{P} While r₁
P-- {(r₁ and 1)▶Hex+3}→P r₁/2→r₁
End Disp P,i Return</lang>
Batch File
This num2bin.bat file handles non-negative input as per the requirements with no leading zeros in the output. Batch only supports signed integers. This script also handles negative values by printing the appropriate two's complement notation. <lang dos>@echo off
- num2bin IntVal [RtnVar]
setlocal enableDelayedExpansion set /a n=%~1 set rtn= for /l %%b in (0,1,31) do ( set /a "d=n&1, n>>=1" set rtn=!d!!rtn! ) for /f "tokens=* delims=0" %%a in ("!rtn!") do set rtn=%%a (endlocal & rem -- return values if "%~2" neq "" (set %~2=%rtn%) else echo %rtn% )
exit /b</lang>
BBC BASIC
<lang bbcbasic> FOR num% = 0 TO 16
PRINT FN_tobase(num%, 2, 0) NEXT END REM Convert N% to string in base B% with minimum M% digits: DEF FN_tobase(N%,B%,M%) LOCAL D%,A$ REPEAT D% = N%MODB% N% DIV= B% IF D%<0 D% += B%:N% -= 1 A$ = CHR$(48 + D% - 7*(D%>9)) + A$ M% -= 1 UNTIL (N%=FALSE OR N%=TRUE) AND M%<=0 =A$</lang>
The above is a generic "Convert to any base" program. Here is a faster "Convert to Binary" program: <lang bbcbasic>PRINT FNbinary(5) PRINT FNbinary(50) PRINT FNbinary(9000) END
DEF FNbinary(N%) LOCAL A$ REPEAT
A$ = STR$(N% AND 1) + A$ N% = N% >>> 1 : REM BBC Basic prior to V5 can use N% = N% DIV 2
UNTIL N% = 0 =A$</lang>
bc
<lang bc>obase = 2 5 50 9000 quit</lang>
Befunge
Reads the number to convert from standard input. <lang befunge>&>0\55+\:2%68>*#<+#8\#62#%/#2:_$>:#,_$@</lang>
- Output:
9000 10001100101000
Bracmat
<lang bracmat> ( dec2bin
= bit bits . :?bits & whl ' ( !arg:>0 & mod$(!arg,2):?bit & div$(!arg,2):?arg & !bit !bits:?bits ) & (str$!bits:~|0) )
& 0 5 50 9000 423785674235000123456789:?numbers & whl
' ( !numbers:%?dec ?numbers & put$(str$(!dec ":\n" dec2bin$!dec \n\n)) )
- </lang>
Output:
0: 0 5: 101 50: 110010 9000: 10001100101000 423785674235000123456789: 1011001101111010111011110101001101111000000000000110001100000100111110100010101
Brainf***
This is almost an exact duplicate of Count in octal#Brainf***. It outputs binary numbers until it is forced to terminate or the counter overflows to 0.
<lang bf>+[ Start with n=1 to kick off the loop [>>++<< Set up {n 0 2} for divmod magic [->+>- Then [>+>>]> do [+[-<+>]>+>>] the <<<<<<] magic >>>+ Increment n % 2 so that 0s don't break things >] Move into n / 2 and divmod that unless it's 0 -< Set up sentinel ‑1 then move into the first binary digit [++++++++ ++++++++ ++++++++ Add 47 to get it to ASCII
++++++++ ++++++++ +++++++. and print it
[<]<] Get to a 0; the cell to the left is the next binary digit >>[<+>-] Tape is {0 n}; make it {n 0} >[>+] Get to the ‑1 <[[-]<] Zero the tape for the next iteration ++++++++++. Print a newline [-]<+] Zero it then increment n and go again</lang>
Burlesque
<lang burlesque> blsq ) {5 50 9000}{2B!}m[uN 101 110010 10001100101000 </lang>
C
Converts int to a string. <lang c>#include <stdio.h>
void bin(int x, char *s) { char*_(int x){ *(s = x ? _(x >> 1) : s) = (x & 1) + '0'; return ++s; } *_(x) = 0; }
int main() { char a[100]; int i; for (i = 0; i <= 1984; i += 31) bin(i, a), printf("%4d: %s\n", i, a);
return 0; }</lang> Converts int to a string. <lang c>#include <stdio.h>
void IntToBitString(unsigned int number) {
int num_bits = sizeof(unsigned int) * 8;
bool startPrinting = false; for (int bit_pos=num_bits-1; bit_pos >= 0; bit_pos--) { bool isBitSet = (number & (1<<bit_pos)) != 0;
if (!startPrinting && isBitSet) startPrinting = true;
if (startPrinting || bit_pos==0) printf("%s", isBitSet ? "1":"0"); }
printf("\r\n");
}
int main() {
IntToBitString(0); IntToBitString(5); IntToBitString(50); IntToBitString(9000);
return 0;
}</lang>
C++
<lang cpp>#include <bitset>
- include <iostream>
- include <limits>
- include <string>
void print_bin(unsigned int n) {
std::string str = "0";
if (n > 0) { str = std::bitset<std::numeric_limits<unsigned int>::digits>(n).to_string(); str = str.substr(str.find('1')); // remove leading zeros } std::cout << str << '\n';
}
int main() {
print_bin(0); print_bin(5); print_bin(50); print_bin(9000);
} </lang> Output:
0 101 110010 10001100101000
Clojure
<lang clojure>(Integer/toBinaryString 5) (Integer/toBinaryString 50) (Integer/toBinaryString 9000)</lang>
COBOL
<lang COBOL> IDENTIFICATION DIVISION.
PROGRAM-ID. SAMPLE.
DATA DIVISION. WORKING-STORAGE SECTION.
01 binary_number pic X(21). 01 str pic X(21). 01 binary_digit pic X. 01 digit pic 9. 01 n pic 9(7). 01 nstr pic X(7).
PROCEDURE DIVISION. accept nstr move nstr to n perform until n equal 0 divide n by 2 giving n remainder digit move digit to binary_digit string binary_digit DELIMITED BY SIZE binary_number DELIMITED BY SPACE into str move str to binary_number end-perform. display binary_number stop run.
</lang> Free-form, using a reference modifier to index into binary-number. <lang cobol>IDENTIFICATION DIVISION. PROGRAM-ID. binary-conversion.
DATA DIVISION. WORKING-STORAGE SECTION. 01 binary-number pic X(21). 01 digit pic 9. 01 n pic 9(7). 01 nstr pic X(7). 01 ptr pic 99.
PROCEDURE DIVISION. display "Number: " with no advancing. accept nstr. move nstr to n. move zeroes to binary-number. move length binary-number to ptr. perform until n equal 0 divide n by 2 giving n remainder digit move digit to binary-number(ptr:1) subtract 1 from ptr if ptr < 1 exit perform end-if end-perform. display binary-number. stop run.</lang>
CoffeeScript
<lang coffeescript>binary = (n) ->
new Number(n).toString(2)
console.log binary n for n in [5, 50, 9000]</lang>
Common Lisp
Just print the number with "~b": <lang lisp>(format t "~b" 5)</lang>
C#
<lang csharp>using System;
class Program {
static void Main() { foreach (var number in new[] { 5, 50, 9000 }) { Console.WriteLine(Convert.ToString(number, 2)); } }
}</lang> Output:
101 110010 10001100101000
Component Pascal
BlackBox Component Builder <lang oberon2> MODULE BinaryDigits; IMPORT StdLog,Strings;
PROCEDURE Do*;
VAR
str : ARRAY 33 OF CHAR;
BEGIN
Strings.IntToStringForm(5,2,32,'0',FALSE,str);
StdLog.Int(5);StdLog.String(":> " + str);StdLog.Ln;
Strings.IntToStringForm(50,2,32,'0',FALSE,str);
StdLog.Int(50);StdLog.String(":> " + str);StdLog.Ln;
Strings.IntToStringForm(9000,2,32,'0',FALSE,str);
StdLog.Int(9000);StdLog.String(":> " + str);StdLog.Ln;
END Do;
END BinaryDigits.
</lang>
Execute: ^Q BinaryDigits.Do
Output:
5:> 00000000000000000000000000000101 50:> 00000000000000000000000000110010 9000:> 00000000000000000010001100101000
D
<lang d>void main() {
import std.stdio;
foreach (immutable i; 0 .. 16) writefln("%b", i);
}</lang>
- Output:
0 1 10 11 100 101 110 111 1000 1001 1010 1011 1100 1101 1110 1111
Dart
<lang dart>String binary(int n) {
if(n<0) throw new IllegalArgumentException("negative numbers require 2s complement"); if(n==0) return "0"; String res=""; while(n>0) { res=(n%2).toString()+res; n=(n/2).toInt(); } return res;
}
main() {
print(binary(0)); print(binary(1)); print(binary(5)); print(binary(10)); print(binary(50)); print(binary(9000)); print(binary(65535)); print(binary(0xaa5511ff)); print(binary(0x123456789abcde)); // fails due to precision limit print(binary(0x123456789abcdef));
}</lang>
dc
<lang dc>2o 5p 50p 9000p</lang>
- Output:
101 110010 10001100101000
Delphi/Pascal
small improvement. Prepending is very time consuming. <lang Delphi>{$IFDEF FPC}
{$MODE DELPHI} {$OPTIMIZATION ON,Regvar,ASMCSE,CSE,PEEPHOLE}
{$ELSE}
{$APPTYPE CONSOLE}
{$ENDIF} uses
sysutils; //only for timing
function IntToBinStrNew(AInt : LongWord):string; const
IO : array[0..1] of char = ('.','X');
var
idx,m : LongWord; pC : pChar;
begin
IF AInt = 0 then Begin result := IO[0];EXIT;end; // search for the first set bit idx:= 32;m := 1 shl (idx-1); While ORD((AInt AND m) = 0)+ORD(m>0) = 2 do begin dec(idx);m := m shr 1;end;
//set right length and insert one by one setlength(result,idx); pC := @result[1]; repeat pC^ := IO[ORD((AInt and m) <> 0)]; m := m shr 1; inc(pC); until m=0;
end;
function IntToBinStr(AInt : LongWord) : string; begin
Result := ; repeat Result := Chr(Ord('0')+(AInt and 1))+Result; AInt := AInt div 2; until (AInt = 0);
end;
procedure Binary_Digits; begin
writeln(' 5: ',IntToBinStr(5)); writeln(' 5: ',IntToBinStrNew(5)); writeln(' 50: ',IntToBinStr(50)); writeln(' 50: ',IntToBinStrNew(50)); writeln('9000: '+IntToBinStr(9000)); writeln('9000: '+IntToBinStrNew(9000));
end;
var
i: LongInt; t :TDateTime;
Begin
Binary_Digits; //speed test t := time; For i := 1 to 10*1000*1000 do IntToBinStrNew(i);t := time-t; Writeln(' New ',t*86400.0:6:3); t := time; For i := 1 to 10*1000*1000 do IntToBinStr(i);t := time-t; Writeln(' Old ',t*86400.0:6:3);
end.</lang>
- output
5: 101 5: X.X 50: 110010 50: XX..X. 9000: 10001100101000 9000: X...XX..X.X... New 0.607 Old 12.315
Elena
<lang elena>#define system.
- define system'routines.
- define extensions.
- symbol program =
[
(5,50,9000) run &each: n [ console writeLine:(n toLiteral &base:2). ].
].</lang>
- Output:
101 110010 10001100101000
Erlang
<lang erlang>lists:map( fun(N) -> io:fwrite("~.2B~n", [N]) end, [5, 50, 9000]). </lang> Output:
101 110010 10001100101000
Euphoria
<lang euphoria>function toBinary(integer i)
sequence s s = {} while i do s = prepend(s, '0'+and_bits(i,1)) i = floor(i/2) end while return s
end function
puts(1, toBinary(5) & '\n') puts(1, toBinary(50) & '\n') puts(1, toBinary(9000) & '\n')</lang>
F#
Translation of C# <lang FSharp> open System for i in [5; 50; 9000] do (Console.WriteLine Convert.ToString (i, 2)) </lang>
Factor
<lang factor>USING: io kernel math math.parser ;
5 >bin print 50 >bin print 9000 >bin print</lang>
Forth
<lang forth>\ Forth uses a system variable 'BASE' for number conversion
\ HEX is a standard word to change the value of base to 16 \ DECIMAL is a standard word to change the value of base to 10
\ we can easily compile a word into the system to set 'BASE' to 2
: binary 2 base ! ; ok
\ interactive console test with conversion and binary masking example
hex 0FF binary . 11111111 ok decimal 679 binary . 1010100111 ok
ok
binary 11111111111 00000110000 and . 110000 ok
decimal ok
</lang>
Fortran
Please find compilation instructions and the example run at the start of the FORTRAN90 source that follows. Thank you. <lang FORTRAN> !-*- mode: compilation; default-directory: "/tmp/" -*- !Compilation started at Sun May 19 23:14:14 ! !a=./F && make $a && $a < unixdict.txt !f95 -Wall -ffree-form F.F -o F !101 !110010 !10001100101000 ! !Compilation finished at Sun May 19 23:14:14 ! ! ! tobin=: -.&' '@":@#: ! tobin 5 !101 ! tobin 50 !110010 ! tobin 9000 !10001100101000
program bits
implicit none integer, dimension(3) :: a integer :: i data a/5,50,9000/ do i = 1, 3 call s(a(i)) enddo
contains
subroutine s(a) integer, intent(in) :: a integer :: i if (a .eq. 0) then write(6,'(a)')'0' return endif do i = 31, 0, -1 if (btest(a, i)) exit enddo do while (0 .lt. i) if (btest(a, i)) then write(6,'(a)',advance='no')'1' else write(6,'(a)',advance='no')'0' endif i = i-1 enddo if (btest(a, i)) then write(6,'(a)')'1' else write(6,'(a)')'0' endif end subroutine s
end program bits </lang>
FunL
<lang funl>for n <- [5, 50, 9000, 9000000000]
println( n, bin(n) )</lang>
- Output:
5, 101 50, 110010 9000, 10001100101000 9000000000, 1000011000011100010001101000000000
Go
<lang go>package main
import ( "fmt" )
func main() { for i := 0; i < 16; i++ { fmt.Printf("%b\n", i) } }</lang>
- Output:
0 1 10 11 100 101 110 111 1000 1001 1010 1011 1100 1101 1110 1111
Groovy
Solutions: <lang groovy>print
n binary
---------------
[5, 50, 9000].each {
printf('%5d %15s\n', it, Integer.toBinaryString(it))
}</lang> Output:
n binary ----- --------------- 5 101 50 110010 9000 10001100101000
Haskell
<lang haskell>import Data.List import Numeric import Text.Printf
-- Use the built-in function showIntAtBase. toBin n = showIntAtBase 2 ("01" !!) n ""
-- Implement our own version. toBin' 0 = [] toBin' x = (toBin' $ x `div` 2) ++ (show $ x `mod` 2)
printToBin n = putStrLn $ printf "%4d %14s %14s" n (toBin n) (toBin' n)
main = do
putStrLn $ printf "%4s %14s %14s" "N" "toBin" "toBin'" mapM_ printToBin [5, 50, 9000]</lang>
Sample output:
N toBin toBin' 5 101 101 50 110010 110010 9000 10001100101000 10001100101000
Icon and Unicon
There is no built-in way to output the bit string representation of an whole number in Icon and Unicon. There are generalized radix conversion routines in the Icon Programming Library that comes with every distribution. This procedure is a customized conversion routine that will populate and use a tunable cache as it goes. <lang Icon>procedure main() every i := 5 | 50 | 255 | 1285 | 9000 do
write(i," = ",binary(i))
end
procedure binary(n) #: return bitstring for integer n static CT, cm, cb initial {
CT := table() # cache table for results cm := 2 ^ (cb := 4) # (tunable) cache modulus & pad bits }
b := "" # build reversed bit string while n > 0 do { # use cached result ...
if not (b ||:= \CT[1(i := n % cm, n /:= cm) ]) then { CT[j := i] := "" # ...or start new cache entry while j > 0 do CT[i] ||:= "01"[ 1(1+j % 2, j /:= 2 )] b ||:= CT[i] := left(CT[i],cb,"0") # finish cache with padding } }
return reverse(trim(b,"0")) # nothing extraneous end</lang> Output:
5 = 101 50 = 110010 255 = 11111111 1285 = 10100000101 9000 = 10001100101000
Idris
<lang Idris>module Main
binaryDigit : Integer -> Char binaryDigit n = if (mod n 2) == 1 then '1' else '0'
binaryString : Integer -> String binaryString 0 = "0" binaryString n = pack (loop n [])
where loop : Integer -> List Char -> List Char loop 0 acc = acc loop n acc = loop (div n 2) (binaryDigit n :: acc)
main : IO () main = do
putStrLn (binaryString 0) putStrLn (binaryString 5) putStrLn (binaryString 50) putStrLn (binaryString 9000)
</lang>
Output:
0 101 110010 10001100101000
J
<lang j> tobin=: -.&' '@":@#:
tobin 5
101
tobin 50
110010
tobin 9000
10001100101000</lang> Algorithm: Remove spaces from the character list which results from formatting the binary list which represents the numeric argument.
I am using implicit output.
Java
<lang java>public class Main {
public static void main(String[] args) { System.out.println(Integer.toBinaryString(5)); System.out.println(Integer.toBinaryString(50)); System.out.println(Integer.toBinaryString(9000)); }
}</lang> Output:
101 110010 10001100101000
JavaScript
<lang javascript>function toBinary(number) {
return new Number(number).toString(2);
} var demoValues = [5, 50, 9000]; for (var i=0; i<demoValues.length; ++i) {
print(toBinary(demoValues[i])); // alert() in a browser, wscript.echo in WSH, etc.
}</lang> Output:
101 110010 10001100101000
Joy
<lang joy>HIDE _ == [null] [pop] [2 div swap] [48 + putch] linrec IN int2bin == [null] [48 + putch] [_] ifte '\n putch END</lang> Using int2bin: <lang joy>0 setautoput 0 int2bin 5 int2bin 50 int2bin 9000 int2bin.</lang>
jq
<lang jq>def binary_digits:
if . == 0 then "0" else [recurse( if . == 0 then empty else ./2 | floor end ) % 2 | tostring] | reverse | .[1:] # remove the leading 0 | join("") end ;
- The task:
(5, 50, 9000) | binary_digits</lang>
- Output:
$ jq -n -r -f Binary_digits.jq 101 110010 10001100101000
Julia
<lang Julia> for i in [0, 5, 50, 9000]
println(i, " => ", bin(i))
end </lang>
- Output:
0 => 0 5 => 101 50 => 110010 9000 => 10001100101000
K
<lang k> tobin: ,/$2_vs
tobin' 5 50 9000
("101"
"110010" "10001100101000")</lang>
Lang5
<lang lang5>'%b '__number_format set [5 50 9000] [3 1] reshape .</lang>
- Output:
[ [ 101 ] [ 110010 ] [ 10001100101000 ] ]
LFE
If one is simple printing the results and doesn't need to use them (e.g., assign them to any variables, etc.), this is very concise: <lang lisp> (: io format '"~.2B~n~.2B~n~.2B~n" (list 5 50 9000)) </lang>
If, however, you do need to get the results from a function, you can use (: erlang integer_to_list ... )
. Here's a simple example that does the same thing as the previous code:
<lang lisp>
(: lists foreach
(lambda (x) (: io format '"~s~n" (list (: erlang integer_to_list x 2)))) (list 5 50 9000))
</lang>
Both of these give the same output:
101 110010 10001100101000
Liberty BASIC
<lang lb>for a = 0 to 16 print a;"=";dec2bin$(a) next a=50:print a;"=";dec2bin$(a) a=254:print a;"=";dec2bin$(a) a=9000:print a;"=";dec2bin$(a) wait
function dec2bin$(num)
if num=0 then dec2bin$="0":exit function while num>0 dec2bin$=str$(num mod 2)+dec2bin$ num=int(num/2) wend
end function </lang>
Locomotive Basic
<lang locobasic>10 PRINT BIN$(5) 20 PRINT BIN$(50) 30 PRINT BIN$(9000)</lang> Output:
101 110010 10001100101000
LOLCODE
This program prints binary digits until it is forced to terminate or the counter overflows to 0. It's almost an exact duplicate of Count in octal#LOLCODE.
<lang LOLCODE>HAI 1.3
HOW IZ I binary YR num
I HAS A digit, I HAS A bin ITZ "" IM IN YR binarizer digit R MOD OF num AN 2 bin R SMOOSH digit bin MKAY num R QUOSHUNT OF num AN 2 NOT num, O RLY? YA RLY, FOUND YR bin OIC IM OUTTA YR binarizer
IF U SAY SO
IM IN YR printer UPPIN YR num
VISIBLE I IZ binary YR num MKAY
IM OUTTA YR printer
KTHXBYE</lang>
Maple
<lang Maple> > convert( 50, 'binary' ); 110010 > convert( 9000, 'binary' ); 10001100101000 </lang>
Mathematica
<lang Mathematica>StringJoin @@ ToString /@ IntegerDigits[50, 2] </lang>
MATLAB / Octave
<lang Matlab> dec2bin(5)
dec2bin(50) dec2bin(9000) </lang>
The output is a string containing ascii(48) (i.e. '0') and ascii(49) (i.e. '1').
Maxima
<lang maxima>digits([arg]) := block(
[n: first(arg), b: if length(arg) > 1 then second(arg) else 10, v: [ ], q], do ( [n, q]: divide(n, b), v: cons(q, v), if n=0 then return(v)))$
binary(n) := simplode(digits(n, 2))$ binary(9000); /*
10001100101000
- /</lang>
Mercury
<lang mercury>:- module binary_digits.
- - interface.
- - import_module io.
- - pred main(io::di, io::uo) is det.
- - implementation.
- - import_module int, list, string.
main(!IO) :-
list.foldl(print_binary_digits, [5, 50, 9000], !IO).
- - pred print_binary_digits(int::in, io::di, io::uo) is det.
print_binary_digits(N, !IO) :-
io.write_string(int_to_base_string(N, 2), !IO), io.nl(!IO).</lang>
Modula-3
<lang modula3>MODULE Binary EXPORTS Main;
IMPORT IO, Fmt;
VAR num := 10;
BEGIN
IO.Put(Fmt.Int(num, 2) & "\n"); num := 150; IO.Put(Fmt.Int(num, 2) & "\n");
END Binary.</lang> Output:
1010 10010110
NetRexx
<lang NetRexx>/* NetRexx */ options replace format comments java crossref symbols nobinary
runSample(arg) return
method getBinaryDigits(nr) public static
bd = nr.d2x.x2b.strip('L', 0) if bd.length = 0 then bd = 0 return bd
method runSample(arg) public static
parse arg list if list = then list = '0 5 50 9000' loop n_ = 1 to list.words w_ = list.word(n_) say w_.right(20)':' getBinaryDigits(w_) end n_</lang>
- Output:
0: 0 5: 101 50: 110010 9000: 10001100101000
Nim
<lang nim>proc binDigits(x: BiggestInt, r: int): int =
## Calculates how many digits `x` has when each digit covers `r` bits. result = 1 var y = x shr r while y > 0: y = y shr r inc(result)
proc toBin*(x: BiggestInt, len: Natural = 0): string =
## converts `x` into its binary representation. The resulting string is ## always `len` characters long. By default the length is determined ## automatically. No leading ``0b`` prefix is generated. var mask: BiggestInt = 1 shift: BiggestInt = 0 len = if len == 0: binDigits(x, 1) else: len result = newString(len) for j in countdown(len-1, 0): result[j] = chr(int((x and mask) shr shift) + ord('0')) shift = shift + 1 mask = mask shl 1
for i in 0..15:
echo toBin(i)</lang>
Output:
0 1 10 11 100 101 110 111 1000 1001 1010 1011 1100 1101 1110 1111
Oberon-2
<lang oberon2> MODULE BinaryDigits; IMPORT
Object, SYSTEM, Out; PROCEDURE Reverse(VAR str: ARRAY OF CHAR); VAR s,e: LONGINT; c: CHAR; BEGIN e := LEN(str) - 1; WHILE (e >= 0) & (str[e] = 0X) DO DEC(e) END; s := 0; WHILE (s < e) DO c := str[s]; str[s] := str[e]; str[e] := c; INC(s);DEC(e) END END Reverse; PROCEDURE IntToOct*(x: LONGINT):STRING; VAR i: LONGINT; o: ARRAY 12 OF CHAR; BEGIN o[LEN(o) - 1] := 0X; i := 0; WHILE (i < LEN(o) - 1) DO o[i] := CHR(ORD('0') + (x MOD 8)); INC(i);x := SYSTEM.LSH(x,-3) END; Reverse(o); RETURN Object.NewLatin1(o) END IntToOct; PROCEDURE IntToHex*(x: LONGINT):STRING; VAR i: LONGINT; h: ARRAY 9 OF CHAR; hexDigit: LONGINT; BEGIN h[LEN(h) - 1] := 0X; i := 0; WHILE (i < LEN(h) - 1) DO hexDigit := x MOD 16; IF (hexDigit >= 0) & (hexDigit <= 9) THEN h[i] := CHR(ORD('0') + hexDigit); ELSE h[i] := CHR(ORD('A') + (hexDigit - 10)); END; INC(i);x := SYSTEM.LSH(x,-4) END; Reverse(h); RETURN Object.NewLatin1(h) END IntToHex;
PROCEDURE IntToBin*(x: LONGINT):STRING; VAR i: LONGINT; b: ARRAY 33 OF CHAR; BEGIN b[LEN(b) - 1] := 0X; i := 0; WHILE (i < LEN(b) - 1) DO b[i] := CHR(ORD('0') + (x MOD 2)); INC(i);x := SYSTEM.LSH(x,-1) END;
Reverse(b); RETURN Object.NewLatin1(b); END IntToBin;
BEGIN
Out.Object("12 :> " + IntToBin(12));Out.Ln; Out.Object("-12 :> " + IntToBin(-12));Out.Ln; Out.Object("MAX(LONGINT) :> " + IntToBin(MAX(LONGINT)));Out.Ln; Out.Object("MIN(LONGINT) :> " + IntToBin(MIN(LONGINT)));Out.Ln;
END BinaryDigits. </lang>
- Output:
12 :> 00000000000000000000000000001100 -12 :> 11111111111111111111111111110100 MAX(LONGINT) :> 01111111111111111111111111111111 MIN(LONGINT) :> 10000000000000000000000000000000
Objeck
<lang objeck> bundle Default {
class Binary { function : Main(args : String[]) ~ Nil { 5->ToBinaryString()->PrintLine(); 50->ToBinaryString()->PrintLine(); 9000->ToBinaryString()->PrintLine(); } }
} </lang>
OCaml
<lang ocaml>let bin_of_int d =
if d < 0 then invalid_arg "bin_of_int" else if d = 0 then "0" else let rec aux acc d = if d = 0 then acc else aux (string_of_int (d land 1) :: acc) (d lsr 1) in String.concat "" (aux [] d)
let () =
let d = read_int () in Printf.printf "%8s\n" (bin_of_int d)</lang>
Oforth
- Output:
>5 asStringOfBase(2) println 101 ok >50 asStringOfBase(2) println 110010 ok >9000 asStringOfBase(2) println 10001100101000 ok >423785674235000123456789 asStringOfBase(2) println 1011001101111010111011110101001101111000000000000110001100000100111110100010101 ok
OxygenBasic
The Assembly code uses block structures to minimise the use of labels. <lang oxygenbasic>
function BinaryBits(sys n) as string
string buf=nuls 32 sys p=strptr buf sys le mov eax,n mov edi,p mov ecx,32 ' 'STRIP LEADING ZEROS ( dec ecx jl fwd done shl eax,1 jnc repeat ) 'PLACE DIGITS ' mov byte [edi],49 '1' inc edi ( cmp ecx,0 jle exit mov dl,48 '0' shl eax,1 ( jnc exit mov dl,49 '1' ) mov [edi],dl inc edi dec ecx repeat ) done: ' sub edi,p mov le,edi if le then return left buf,le return "0"
end function
print BinaryBits 0xaa 'result 10101010 </lang>
PARI/GP
<lang parigp>bin(n:int)=concat(apply(s->Str(s),binary(n)))</lang>
Perl
<lang perl>for (5, 50, 9000) {
printf "%b\n", $_;
}</lang>
101 110010 10001100101000
Perl 6
<lang perl6>say .fmt("%b") for 5, 50, 9000;</lang>
101 110010 10001100101000
Phix
<lang Phix>printf(1,"%b\n",5) printf(1,"%b\n",50) printf(1,"%b\n",9000)</lang>
- Output:
101 110010 10001100101000
PHP
<lang php><?php echo decbin(5); echo decbin(50); echo decbin(9000);</lang> Output:
101 110010 10001100101000
PicoLisp
<lang PicoLisp>: (bin 5) -> "101"
- (bin 50)
-> "110010"
- (bin 9000)
-> "10001100101000"</lang>
Piet
Rendered as wikitable, because image upload is not possible:
ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww |
ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww |
ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww |
ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww |
ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww |
ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww |
ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww | ww |
Examples:
? 5 101 ? 50 110010 ? 9000 10001100101000
Explanation of program flow and image download link on my user page: [1]
PL/I
Displays binary output trivially, but with leading zeros: <lang pli>put edit (25) (B);</lang>
Output: 0011001
With leading zero suppression: <lang pli> declare text character (50) initial (' ');
put string(text) edit (25) (b); put skip list (trim(text, '0'));
put string(text) edit (2147483647) (b); put skip list (trim(text, '0'));</lang>
- Output:
11001 1111111111111111111111111111111
PowerShell
<lang PowerShell>@(5,50,900) | foreach-object { [Convert]::ToString($_,2) }</lang> Output:
101 110010 1110000100
Prolog
<lang prolog> binary(X) :- format('~2r~n', [X]). main :- maplist(binary, [5,50,9000]), halt. </lang>Sample output:
101 110010 10001100101000
PureBasic
<lang PureBasic>If OpenConsole()
PrintN(Bin(5)) ;101 PrintN(Bin(50)) ;110010 PrintN(Bin(9000)) ;10001100101000 Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input() CloseConsole()
EndIf</lang> Sample output:
101 110010 10001100101000
Python
<lang python>>>> for i in range(16): print('{0:b}'.format(i))
0 1 10 11 100 101 110 111 1000 1001 1010 1011 1100 1101 1110 1111</lang>
<lang python>>>> for i in range(16): print(bin(i))
0b0 0b1 0b10 0b11 0b100 0b101 0b110 0b111 0b1000 0b1001 0b1010 0b1011 0b1100 0b1101 0b1110 0b1111</lang> Pre-Python 2.6: <lang python>>>> oct2bin = {'0': '000', '1': '001', '2': '010', '3': '011', '4': '100', '5': '101', '6': '110', '7': '111'} >>> bin = lambda n: .join(oct2bin[octdigit] for octdigit in '%o' % n).lstrip('0') or '0' >>> for i in range(16): print(bin(i))
0 1 10 11 100 101 110 111 1000 1001 1010 1011 1100 1101 1110 1111</lang>
Racket
<lang racket>
- lang racket
- Option 1
- binary formatter
(for ([i 16]) (printf "~b\n" i))
- Option 2
- explicit conversion
(for ([i 16]) (displayln (number->string i 2))) </lang>
Retro
<lang Retro>9000 50 5 3 [ binary putn cr decimal ] times</lang>
REXX
This version handles the special case of zero simply.
simple version
Note: some REXX interpreters have a D2B [Decimal to Binary] BIF (built-in function).
Programming note: this REXX version depends on numeric digits being large enough to handle leading zeroes in this manner (by adding a zero (to the binary version) to force leading zero suppression).
<lang REXX>/*REXX program demonstrates converting decimal ───► binary. */
numeric digits 1000
x.=
x.1 = 0
x.2 = 5
x.3 = 50
x.4 = 9000
do j=1 while x.j\== /*compute until a NULL is found.*/ y = x2b(d2x(x.j)) + 0 /*force removal of leading zeroes*/ say right(x.j,20) 'decimal, and in binary:' y end /*j*/ /*stick a fork in it, we're done.*/</lang>
output
0 decimal, and in binary: 0 5 decimal, and in binary: 101 50 decimal, and in binary: 110010 9000 decimal, and in binary: 10001100101000
elegant version
This version handles the case of zero as a special case more elegantly.
The following versions depend on the setting of numeric digits such that the number in decimal can be expressed as a whole number.
<lang REXX>/*REXX program demonstrates converting decimal ───► binary. */
x.=
x.1 = 0
x.2 = 5
x.3 = 50
x.4 = 9000
do j=1 while x.j\== /*compute until a NULL is found.*/ y = strip( x2b( d2x( x.j )), 'L', 0) if y== then y=0 /*handle special case of 0 (zero)*/ say right(x.j,20) 'decimal, and in binary:' y end /*j*/ /*stick a fork in it, we're done.*/</lang>
output is identical to the 1st version.
concise version
This version handles the case of zero a bit more obtusely, but concisely. <lang REXX>/*REXX program demonstrates converting decimal ───► binary. */ x.= x.1=0 x.2=5 x.3=50 x.4=9000
do j=1 while x.j\== /*compute until a NULL is found.*/ y = word( strip( x2b( d2x( x.j )), 'L', 0) 0, 1) say right(x.j,20) 'decimal, and in binary:' y end /*j*/ /*stick a fork in it, we're done.*/</lang>
output is identical to the 1st version.
conforming version
This REXX version conforms to the strict output requirements of this task (just show the binary output without any blanks). <lang REXX>/*REXX program demonstrates converting decimal ───► binary. */ numeric digits 200 x.= x.1=0 x.2=5 x.3=50 x.4=9000 x.5=423785674235000123456789 x.6=1e138 /*one quinquaquadragintillion. */
do j=1 while x.j\== /*compute until a NULL is found.*/ y = strip( x2b( d2x( x.j )), 'L', 0) if y== then y=0 /*handle special case of 0 (zero)*/ say y end /*j*/ /*stick a fork in it, we're done.*/</lang>
output
0 101 110010 10001100101000 1011001101111010111011110101001101111000000000000110001100000100111110100010101 101010111111101001000101110110100000111011011011110111100110100100000100100001111101101110011101000101110110001101101000100100100110000111001010101011110010001111100011110100010101011011111111000110101110111100001011100111110000000010101100110101001010001001001011000000110000010010010100010010000001110100101000011111001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Ruby
<lang ruby>[5,50,9000].each do |n|
puts "%b" % n
end</lang> or <lang ruby>for n in [5,50,9000]
puts n.to_s(2)
end</lang> Output:
101 110010 10001100101000
Run BASIC
<lang runbasic>input "Number to convert:";a while 2^(n+1) < a
n = n + 1
wend
for i = n to 0 step -1
x = 2^i if a >= x then print 1; a = a - x else print 0; end if
next</lang> Output:
Number to convert:?9000 10001100101000
Rust
<lang rust>fn main() {
for i in 0..8 { println!("{:b}", i) }
}</lang> Outputs:
0 1 10 11 100 101 110 111
Scala
Scala has an implicit conversion from Int
to RichInt
which has a method toBinaryString
.
<lang scala>scala> (5 toBinaryString)
res0: String = 101
scala> (50 toBinaryString) res1: String = 110010
scala> (9000 toBinaryString) res2: String = 10001100101000</lang>
Scheme
<lang scheme>(display (number->string 5 2)) (newline) (display (number->string 50 2)) (newline) (display (number->string 9000 2)) (newline)</lang>
Seed7
This example uses the radix operator to write a number in binary.
<lang seed7>$ include "seed7_05.s7i";
const proc: main is func
local var integer: number is 0; begin for number range 0 to 16 do writeln(number radix 2); end for; end func;</lang>
Output:
0 1 10 11 100 101 110 111 1000 1001 1010 1011 1100 1101 1110 1111 10000
Sidef
<lang ruby>[5, 50, 9000].each { |n|
say n.as_bin;
}</lang>
- Output:
101 110010 10001100101000
Smalltalk
<lang smalltalk>5 printOn: Stdout radix:2 50 printOn: Stdout radix:2 9000 printOn: Stdout radix:2</lang> or: <lang smalltalk>#(5 50 9000) do:[:each | each printOn: Stdout radix:2. Stdout cr]</lang>
SNUSP
<lang SNUSP>
/recurse\
$,binary!\@\>?!\@/<@\.#
! \=/ \=itoa=@@@+@+++++# /<+>- \ div2 \?!#-?/+# mod2
</lang>
Standard ML
<lang sml>print (Int.fmt StringCvt.BIN 5 ^ "\n"); print (Int.fmt StringCvt.BIN 50 ^ "\n"); print (Int.fmt StringCvt.BIN 9000 ^ "\n");</lang>
Swift
<lang Swift>for num in [5, 50, 9000] {
println(String(num, radix: 2))
}</lang>
- Output:
101 110010 10001100101000
Tcl
<lang tcl>proc num2bin num {
# Convert to _fixed width_ big-endian 32-bit binary binary scan [binary format "I" $num] "B*" binval # Strip useless leading zeros by reinterpreting as a big decimal integer scan $binval "%lld"
}</lang> Demonstrating: <lang tcl>for {set x 0} {$x < 16} {incr x} {
puts [num2bin $x]
} puts "--------------" puts [num2bin 5] puts [num2bin 50] puts [num2bin 9000]</lang> Output:
0 1 10 11 100 101 110 111 1000 1001 1010 1011 1100 1101 1110 1111 -------------- 101 110010 10001100101000
TI-83 BASIC
Using Standard TI-83 BASIC <lang ti83b>PROGRAM:BINARY
- Disp "NUMBER TO"
- Disp "CONVERT:"
- Input A
- 0→N
- 0→B
- While 2^(N+1)≤A
- N+1→N
- End
- While N≥0
- iPart(A/2^N)→C
- 10^(N)*C+B→B
- If C=1
- Then
- A-2^N→A
- End
- N-1→N
- End
- Disp B</lang>
Alternate using a string to display larger numbers. <lang ti83b>PROGRAM:BINARY
- Input X
- " "→Str1
- Repeat X=0
:X/2→X :sub("01",2fPart(X)+1,1)+Str1→Str1 :iPart(X)→X
- End
- Str1</lang>
Using the baseInput() "real(25," function from Omnicalc <lang ti83b>PROGRAM:BINARY
- Disp "NUMBER TO"
- Disp "CONVERT"
- Input "Str1"
- Disp real(25,Str1,10,2)</lang>
More compact version: <lang ti83b>:Input "DEC: ",D
- " →Str1
- If not(D:"0→Str1
- While D>0
- If not(fPart(D/2:Then
- "0"+Str1→Str1
- Else
- "1"+Str1→Str1
- End
- iPart(D/2→D
- End
- Disp Str1
</lang>
UNIX Shell
<lang sh># Define a function to output binary digits tobinary() {
# We use the bench calculator for our conversion echo "obase=2;$1"|bc
}
- Call the function with each of our values
tobinary 5 tobinary 50</lang>
Vedit macro language
This implementation reads the numeric values from user input and writes the converted binary values in the edit buffer. <lang vedit>repeat (ALL) {
#10 = Get_Num("Give a numeric value, -1 to end: ", STATLINE) if (#10 < 0) { break } Call("BINARY") Update()
} return
- BINARY:
do {
Num_Ins(#10 & 1, LEFT+NOCR) #10 = #10 >> 1 Char(-1)
} while (#10 > 0) EOL Ins_Newline Return </lang> Example output when values 0, 1, 5, 50 and 9000 were entered:
0 1 101 110010 10001100101000
Vim Script
<lang vim>function Num2Bin(n)
let n = a:n let s = "" if n == 0 let s = "0" else while n if n % 2 == 0 let s = "0" . s else let s = "1" . s endif let n = n / 2 endwhile endif return s
endfunction
echo Num2Bin(5) echo Num2Bin(50) echo Num2Bin(9000)</lang>
- Output:
101 110010 10001100101000
Visual Basic .NET
<lang vbnet>Sub Main()
Console.WriteLine("5: " & Convert.ToString(5, 2)) Console.WriteLine("50: " & Convert.ToString(50, 2)) Console.WriteLine("9000: " & Convert.ToString(9000, 2))
End Sub</lang> Output:
5: 101 50: 110010 9000: 10001100101000
Visual FoxPro
<lang vfp>
- !* Binary Digits
CLEAR k = CAST(5 As I) ? NToBin(k) k = CAST(50 As I) ? NToBin(k) k = CAST(9000 As I) ? NToBin(k)
FUNCTION NTOBin(n As Integer) As String LOCAL i As Integer, b As String, v As Integer b = "" v = HiBit(n) FOR i = 0 TO v
b = IIF(BITTEST(n, i), "1", "0") + b
ENDFOR RETURN b ENDFUNC
FUNCTION HiBit(n As Double) As Integer
- !* Find the highest power of 2 in n
LOCAL v As Double v = LOG(n)/LOG(2) RETURN FLOOR(v) ENDFUNC </lang>
- Output:
101 110010 10001100101000
Whitespace
This program prints binary numbers until the internal representation of the current integer overflows to -1; it will never do so on some interpreters. It is almost an exact duplicate of Count in octal#Whitespace.
<lang Whitespace>
</lang>
It was generated from the following pseudo-Assembly.
<lang asm>push 0
- Increment indefinitely.
0:
push -1 ; Sentinel value so the printer knows when to stop. copy 1 call 1 push 10 ochr push 1 add jump 0
- Get the binary digits on the stack in reverse order.
1:
dup push 2 mod swap push 2 div push 0 copy 1 sub jn 1 pop
- Print them.
2:
dup jn 3 ; Stop at the sentinel. onum jump 2
3:
pop ret</lang>
Wortel
Using JavaScripts buildin toString method on the Number object, the following function takes a number and returns a string with the binary representation: <lang wortel>\.toString 2
- the following function also casts the string to a number
^(@+ \.toString 2)</lang> To output to the console: <lang wortel>@each ^(console.log \.toString 2) [5 50 900]</lang>
Outputs:
101 110010 1110000100
X86 Assembly
Translation of XPL0. Assemble with tasm, tlink /t <lang asm> .model tiny
.code .486 org 100h
start: mov ax, 5
call binout call crlf mov ax, 50 call binout call crlf mov ax, 9000 call binout
crlf: mov al, 0Dh ;new line
int 29h mov al, 0Ah int 29h ret
binout: push ax
shr ax, 1 je bo10 call binout
bo10: pop ax
and al, 01h or al, '0' int 29h ;display character ret end start</lang>
Output:
101 110010 10001100101000
XPL0
<lang XPL0>include c:\cxpl\codes; \intrinsic code declarations
proc BinOut(N); \Output N in binary int N; int R; [R:= N&1; N:= N>>1; if N then BinOut(N); ChOut(0, R+^0); ];
int I; [I:= 0; repeat BinOut(I); CrLf(0);
I:= I+1;
until KeyHit or I=0; ]</lang>
Example output:
0 1 10 11 100 101 110 111 1000 ... 100000010011110 100000010011111 100000010100000 100000010100001
zkl
<lang zkl>(9000).toString(2)</lang> <lang zkl>T(5,50,9000).apply("toString",2) //--> L("101","110010","10001100101000")</lang> <lang zkl>"%.2B".fmt(9000)</lang>
ZX Spectrum Basic
<lang zxbasic>10 LET n=5: GO SUB 1000: PRINT s$ 20 LET n=50: GO SUB 1000: PRINT s$ 30 LET n=9000: GO SUB 1000: PRINT s$ 999 STOP 1000 REM convert to binary 1010 LET t=n: REM temporary variable 1020 LET s$="": REM this will contain our binary digits 1030 LET sf=0: REM output has not started yet 1040 FOR l=126 TO 0 STEP -1 1050 LET d$="0": REM assume next digit is zero 1060 IF t>=(2^l) THEN LET d$="1": LET t=t-(2^l): LET sf=1 1070 IF (sf <> 0) THEN LET s$=s$+d$ 1080 NEXT l 1090 RETURN</lang>
- Programming Tasks
- Basic language learning
- Radices
- 0815
- 360 Assembly
- ACL2
- Ada
- Aime
- ALGOL 68
- ALGOL W
- AutoHotkey
- AutoIt
- AWK
- Axe
- Batch File
- BBC BASIC
- Bc
- Befunge
- Bracmat
- Brainf***
- Burlesque
- C
- C++
- Clojure
- COBOL
- CoffeeScript
- Common Lisp
- C sharp
- Component Pascal
- Component Pascal examples needing attention
- Examples needing attention
- D
- Dart
- Dc
- Delphi
- Pascal
- Elena
- Erlang
- Euphoria
- F Sharp
- Factor
- Forth
- Fortran
- FunL
- Go
- Groovy
- Haskell
- Icon
- Unicon
- Idris
- J
- Java
- JavaScript
- Joy
- Jq
- Julia
- K
- Lang5
- LFE
- Liberty BASIC
- Locomotive Basic
- LOLCODE
- LOLCODE examples needing attention
- Maple
- Mathematica
- MATLAB
- Octave
- Maxima
- Mercury
- Modula-3
- NetRexx
- Nim
- Oberon-2
- Objeck
- OCaml
- Oforth
- OxygenBasic
- PARI/GP
- Perl
- Perl 6
- Phix
- PHP
- PicoLisp
- Piet
- PL/I
- PowerShell
- Microsoft .NET Framework
- Prolog
- PureBasic
- Python
- Racket
- Retro
- REXX
- Ruby
- Run BASIC
- Rust
- Scala
- Scheme
- Seed7
- Sidef
- Smalltalk
- SNUSP
- Standard ML
- Swift
- Tcl
- TI-83 BASIC
- UNIX Shell
- Vedit macro language
- Vim Script
- Visual Basic .NET
- Visual FoxPro
- Whitespace
- Wortel
- X86 Assembly
- XPL0
- Zkl
- ZX Spectrum Basic