Binary digits

From Rosetta Code
Task
Binary digits
You are encouraged to solve this task according to the task description, using any language you may know.
Task

Create and display 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 built-in 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.

Contents

0815[edit]

}: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:
Output:

Note that 0815 reads numeric input in hexadecimal.

echo -e "5\n32\n2329" | 0815 bin.0
101
110010
10001100101001

360 Assembly[edit]

*        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
Output:
           0 0
           5 101
          50 110010
        9000 10001100101000

8th[edit]

 
2 base drop
#50 . cr
 
Output:
110010

ACL2[edit]

(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)))

Ada[edit]

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;

Aime[edit]

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);
Output:
0
101
110010
10001100101000

ALGOL 68[edit]

Works with: ALGOL 68 version Revision 1.
Works with: ALGOL 68G version Any - tested with release algol68g-2.3.3.
File: Binary_digits.a68
#!/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
))
Output
         +5 => 101
        +50 => 110010
      +9000 => 10001100101000
         +5 => TFT
        +50 => TTFFTF
      +9000 => TFFFTTFFTFTFFF

ALGOL W[edit]

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.


AppleScript[edit]

Translation of: JavaScript


on run
 
intercalate(linefeed, ¬
map(binaryString, [5, 50, 9000]))
 
end run
 
-- binaryString :: Int -> String
on binaryString(n)
 
showIntAtBase(n, 2)
 
end binaryString
 
 
-- showIntAtBase :: Int -> Int -> String
on showIntAtBase(n, base)
if base > 1 then
if n > 0 then
set m to n mod base
set r to n - m
if r > 0 then
set prefix to showIntAtBase(r div base, base)
else
set prefix to ""
end if
 
if m < 10 then
set baseCode to 48 -- "0"
else
set baseCode to 55 -- "A" - 10
end if
 
prefix & character id (baseCode + m)
else
"0"
end if
else
missing value
end if
end showIntAtBase
 
 
 
-- GENERIC FUNCTIONS FOR TESTING
 
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
script mf
property lambda : f
end script
 
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to mf's lambda(item i of xs, i, xs)
end repeat
return lst
end map
 
-- intercalate :: Text -> [Text] -> Text
on intercalate(strText, lstText)
set {dlm, my text item delimiters} to {my text item delimiters, strText}
set strJoined to lstText as text
set my text item delimiters to dlm
return strJoined
end intercalate
 
 


Output:
101
110010
10001100101000

Applesoft BASIC[edit]

 0 N = 5: GOSUB 1:N = 50: GOSUB 1:N = 9000: GOSUB 1: END 
1 LET N2 = ABS ( INT (N))
2 LET B$ = ""
3 FOR N1 = N2 TO 0 STEP 0
4 LET N2 = INT (N1 / 2)
5 LET B$ = STR$ (N1 - N2 * 2) + B$
6 LET N1 = N2
7 NEXT N1
8 PRINT B$
9 RETURN
Output:
101
110010
10001100101000

AutoHotkey[edit]

MsgBox % NumberToBinary(5) ;101
MsgBox % NumberToBinary(50) ;110010
MsgBox % NumberToBinary(9000) ;10001100101000
 
NumberToBinary(InputNumber)
{
While, InputNumber
Result := (InputNumber & 1) . Result, InputNumber >>= 1
Return, Result
}

AutoIt[edit]

 
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
 

AWK[edit]

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
}

Axe[edit]

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.

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

Batch File[edit]

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.

@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

BBC BASIC[edit]

      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$

The above is a generic "Convert to any base" program. Here is a faster "Convert to Binary" program:

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$

bc[edit]

Translation of: dc
obase = 2
5
50
9000
quit

Befunge[edit]

Reads the number to convert from standard input.

&>0\55+\:2%68>*#<+#8\#62#%/#2:_$>:#,_$@
Output:
9000
10001100101000

Bracmat[edit]

  ( 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))
)
;

Output:

0:
0

5:
101

50:
110010

9000:
10001100101000

423785674235000123456789:
1011001101111010111011110101001101111000000000000110001100000100111110100010101

Brainf***[edit]

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.

+[            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

Burlesque[edit]

 
blsq ) {5 50 9000}{2B!}m[uN
101
110010
10001100101000
 

C[edit]

Converts int to a string.

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
 
char *bin(uint32_t x);
 
int main(void)
{
for (size_t i = 0; i < 20; i++) {
char *binstr = bin(i);
printf("%s\n", binstr);
free(binstr);
}
}
 
char *bin(uint32_t x)
{
size_t bits = (x == 0) ? 1 : log10((double) x)/log10(2) + 1;
char *ret = malloc((bits + 1) * sizeof (char));
for (size_t i = 0; i < bits ; i++) {
ret[bits - i - 1] = (x & 1) ? '1' : '0';
x >>= 1;
}
ret[bits] = '\0';
return ret;
}
Output:
0
1
10
11
100
101
110
111
1000
1001
1010
1011
1100
1101
1110
1111
10000
10001
10010
10011

C++[edit]

#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);
}
 

Output:

0
101
110010
10001100101000

Shorter version using bitset

#include <iostream>
#include <bitset>
void printBits(int n) { // Use int like most programming languages.
int iExp = 0; // Bit-length
while (n >> iExp) ++iExp; // Could use template <log(x)*1.44269504088896340736>
for (int at = iExp - 1; at >= 0; at--) // Reverse iter from the bit-length to 0 - msb is at end
std::cout << std::bitset<32>(n)[at]; // Show 1's, show lsb, hide leading zeros
std::cout << '\n';
}
int main(int argc, char* argv[]) {
printBits(5);
printBits(50);
printBits(9000);
} // for testing with n=0 printBits<32>(0);

Using >> operator. (1st example is 2.75x longer. Matter of taste.)

#include <iostream>
int main(int argc, char* argv[]) {
unsigned int in[] = {5, 50, 9000}; // Use int like most programming languages
for (int i = 0; i < 3; i++) // Use all inputs
for (int at = 31; at >= 0; at--) // reverse iteration from the max bit-length to 0, because msb is at the end
if (int b = (in[i] >> at)) // skip leading zeros. Start output when significant bits are set
std::cout << ('0' + b & 1) << (!at ? "\n": ""); // '0' or '1'. Add EOL if last bit of num
}
 

To be fair comparison with languages that doesn't declare a function like C++ main(). 3.14x shorter than 1st example.

#include <iostream>
int main(int argc, char* argv[]) { // Usage: program.exe 5 50 9000
for (int i = 1; i < argc; i++) // argv[0] is program name
for (int at = 31; at >= 0; at--) // reverse iteration from the max bit-length to 0, because msb is at the end
if (int b = (atoi(argv[i]) >> at)) // skip leading zeros
std::cout << ('0' + b & 1) << (!at ? "\n": ""); // '0' or '1'. Add EOL if last bit of num
}

Output:

101
110010
10001100101000

Clojure[edit]

(Integer/toBinaryString 5)
(Integer/toBinaryString 50)
(Integer/toBinaryString 9000)

COBOL[edit]

       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.
 

Free-form, using a reference modifier to index into binary-number.

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.

CoffeeScript[edit]

binary = (n) ->
new Number(n).toString(2)
 
console.log binary n for n in [5, 50, 9000]

Common Lisp[edit]

Just print the number with "~b":

(format t "~b" 5)
 
; or
 
(write 5 :base 2)

C#[edit]

using System;
 
class Program
{
static void Main()
{
foreach (var number in new[] { 5, 50, 9000 })
{
Console.WriteLine(Convert.ToString(number, 2));
}
}
}

Output:

101
110010
10001100101000

Component Pascal[edit]

BlackBox Component Builder

 
MODULE BinaryDigits;
IMPORT StdLog,Strings;
 
PROCEDURE Do*;
VAR
str : ARRAY 33 OF CHAR;
BEGIN
Strings.IntToStringForm(5,2, 1,'0',FALSE,str);
StdLog.Int(5);StdLog.String(":> " + str);StdLog.Ln;
Strings.IntToStringForm(50,2, 1,'0',FALSE,str);
StdLog.Int(50);StdLog.String(":> " + str);StdLog.Ln;
Strings.IntToStringForm(9000,2, 1,'0',FALSE,str);
StdLog.Int(9000);StdLog.String(":> " + str);StdLog.Ln;
END Do;
END BinaryDigits.
 

Execute: ^Q BinaryDigits.Do
Output:

 5:> 101
 50:> 110010
 9000:> 10001100101000

D[edit]

void main() {
import std.stdio;
 
foreach (immutable i; 0 .. 16)
writefln("%b", i);
}
Output:
0
1
10
11
100
101
110
111
1000
1001
1010
1011
1100
1101
1110
1111

Dart[edit]

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));
}

dc[edit]

2o 5p 50p 9000p
Output:
101
110010
10001100101000

Delphi[edit]

 
program BinaryDigit;
{$APPTYPE CONSOLE}
uses
sysutils;
 
function IntToBinStr(AInt : LongWord) : string;
begin
Result := '';
repeat
Result := Chr(Ord('0')+(AInt and 1))+Result;
AInt := AInt div 2;
until (AInt = 0);
end;
 
Begin
writeln(' 5: ',IntToBinStr(5));
writeln(' 50: ',IntToBinStr(50));
writeln('9000: '+IntToBinStr(9000));
end.
output
   5: 101
  50: 110010
9000: 10001100101000

EchoLisp[edit]

 
;; primitive : (number->string number [base]) - default base = 10
 
(number->string 2 2)
10
 
(for-each (compose writeln (rcurry number->string 2)) '( 5 50 9000))
101
110010
10001100101000
 


</lang>

Elena[edit]

#define system.
#define system'routines.
#define extensions.
 
#symbol program =
[
(5,50,9000) run &each: n
[
console writeLine:(n toLiteral &base:2).
].
].
Output:
101
110010
10001100101000

Elixir[edit]

Use Integer.to_string with a base of 2:

 
IO.puts Integer.to_string(5,2)
 

Or, using the pipe operator:

 
5 |> Integer.to_string(2) |> IO.puts
 
 
[5,50,9000] |> Enum.each(fn n -> IO.puts Integer.to_string(n,2) end)
 
Output:
101
110010
10001100101000

Erlang[edit]

lists:map( fun(N) -> io:fwrite("~.2B~n", [N]) end, [5, 50, 9000]). 

Output:

101
110010
10001100101000

Euphoria[edit]

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')

Functional/Recursive[edit]

include std/math.e 
include std/convert.e
 
function Bin(integer n, sequence s = "")
if n > 0 then
return Bin(floor(n/2),(mod(n,2) + #30) & s)
end if
if length(s) = 0 then
return to_integer("0")
end if
return to_integer(s)
end function
 
printf(1, "%d\n", Bin(5))
printf(1, "%d\n", Bin(50))
printf(1, "%d\n", Bin(9000))

F#[edit]

Translation of C#

 
open System
for i in [5; 50; 9000] do (Console.WriteLine Convert.ToString (i, 2))
 

Factor[edit]

USING: io kernel math math.parser ;
 
5 >bin print
50 >bin print
9000 >bin print

FBSL[edit]

#AppType Console
function Bin(byval n as integer, byval s as string = "") as string
if n > 0 then return Bin(n \ 2, (n mod 2) & s)
if s = "" then return "0"
return s
end function
 
print Bin(5)
print Bin(50)
print Bin(9000)
 
pause
 

Forth[edit]

\ 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
 
 

Fortran[edit]

Please find compilation instructions and the example run at the start of the FORTRAN90 source that follows. Thank you.

 
!-*- 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
 

FreeBASIC[edit]

 
' FreeBASIC v1.05.0 win64
Dim As String fmt = "#### -> &"
Print Using fmt; 5; Bin(5)
Print Using fmt; 50; Bin(50)
Print Using fmt; 9000; Bin(9000)
Print
Print "Press any key to exit the program"
Sleep
End
 
Output:
   5 -> 101
  50 -> 110010
9000 -> 10001100101000

FunL[edit]

for n <- [5, 50, 9000, 9000000000]
println( n, bin(n) )
Output:
5, 101
50, 110010
9000, 10001100101000
9000000000, 1000011000011100010001101000000000

Futhark[edit]

We produce the binary number as a 64-bit integer whose digits are all 0s and 1s - this is because Futhark does not have any way to print, nor strings for that matter.

 
fun main(x: i32): i64 =
loop (out = 0i64) = for i < 32 do
let digit = (x >> (31-i)) & 1
let out = (out * 10i64) + i64(digit)
in out
in out
 

Frink[edit]

The following all provide equivalent output. Input can be arbitrarily-large integers.

 
9000 -> binary
9000 -> base2
base2[9000]
base[9000, 2]
 

Go[edit]

package main
 
import (
"fmt"
)
 
func main() {
for i := 0; i < 16; i++ {
fmt.Printf("%b\n", i)
}
}
Output:
0
1
10
11
100
101
110
111
1000
1001
1010
1011
1100
1101
1110
1111

Groovy[edit]

Solutions:

print '''
n binary
----- ---------------
'''

[5, 50, 9000].each {
printf('%5d %15s\n', it, Integer.toBinaryString(it))
}

Output:

  n        binary
----- ---------------
    5             101
   50          110010
 9000  10001100101000

Haskell[edit]

import Data.List
import Numeric
import Text.Printf
 
-- Use the built-in function showIntAtBase.
toBin n = showIntAtBase 2 ("01" !!) n ""
 
-- Implement our own version.
toBin1 0 = []
toBin1 x = (toBin1 $ x `div` 2) ++ (show $ x `mod` 2)
 
printToBin n = putStrLn $ printf "%4d  %14s  %14s" n (toBin n) (toBin1 n)
 
main = do
putStrLn $ printf "%4s  %14s  %14s" "N" "toBin" "toBin1"
mapM_ printToBin [5, 50, 9000]
Sample output:
   N           toBin          toBin1
   5             101             101
  50          110010          110010
9000  10001100101000  10001100101000

Icon and Unicon[edit]

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.

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

Output:

5 = 101
50 = 110010
255 = 11111111
1285 = 10100000101
9000 = 10001100101000


Idris[edit]

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)
 

Output:

0
101
110010
10001100101000

J[edit]

   tobin=: -.&' '@":@#:
tobin 5
101
tobin 50
110010
tobin 9000
10001100101000

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[edit]

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));
}
}

Output:

101
110010
10001100101000

JavaScript[edit]

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.
}

Or, as a functional expression, rather than a statement:

console.log(
 
[5, 50, 9000].map(function (n) {
return (n).toString(2);
}).join('\n')
 
)

Output:

101
110010
10001100101000

Joy[edit]

HIDE
_ == [null] [pop] [2 div swap] [48 + putch] linrec
IN
int2bin == [null] [48 + putch] [_] ifte '\n putch
END

Using int2bin:

0 setautoput
0 int2bin
5 int2bin
50 int2bin
9000 int2bin.

jq[edit]

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
Output:
$ jq -n -r -f Binary_digits.jq
101
110010
10001100101000

Julia[edit]

 
for i in [0, 5, 50, 9000]
println(i, " => ", bin(i))
end
 
Output:
0 => 0
5 => 101
50 => 110010
9000 => 10001100101000

K[edit]

  tobin: ,/$2_vs
tobin' 5 50 9000
("101"
"110010"
"10001100101000")

Lang5[edit]

'%b '__number_format set
[5 50 9000] [3 1] reshape .
Output:
[
  [ 101  ]
  [ 110010  ]
  [ 10001100101000  ]
]

LFE[edit]

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:

 
(: io format '"~.2B~n~.2B~n~.2B~n" (list 5 50 9000))
 

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:

 
(: lists foreach
(lambda (x)
(: io format
'"~s~n"
(list (: erlang integer_to_list x 2))))
(list 5 50 9000))
 

Both of these give the same output:

101
110010
10001100101000

Liberty BASIC[edit]

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
 

Locomotive Basic[edit]

10 PRINT BIN$(5)
20 PRINT BIN$(50)
30 PRINT BIN$(9000)

Output:

101
110010
10001100101000

LOLCODE[edit]

This example is incorrect. Please fix the code and remove this message.
Details: The task is to convert numbers into binary, not count in binary.

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.

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

Lua[edit]

function dec2bin (n)
local bin = ""
while n > 0 do
bin = n % 2 .. bin
n = math.floor(n / 2)
end
return bin
end
 
print(dec2bin(5))
print(dec2bin(50))
print(dec2bin(9000))
Output:
101
110010
10001100101000

Maple[edit]

 
> convert( 50, 'binary' );
110010
> convert( 9000, 'binary' );
10001100101000
 

Mathematica / Wolfram Language[edit]

StringJoin @@ ToString /@ IntegerDigits[50, 2] 

MATLAB / Octave[edit]

  dec2bin(5)
dec2bin(50)
dec2bin(9000)

The output is a string containing ascii(48) (i.e. '0') and ascii(49) (i.e. '1').

Maxima[edit]

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
*/

Mercury[edit]

:- 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).

mLite[edit]

fun binary
(0, b) = implode ` map (fn x = if int x then chr (x + 48) else x) b
| (n, b) = binary (n div 2, n mod 2 :: b)
| n = binary (n, [])
;
 

from the REPL[edit]

mLite
> binary 5;
"101"
> binary 50;
"110010"
> binary 9000;
"10001100101000"

Modula-3[edit]

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.

Output:

1010
10010110

NetRexx[edit]

/* 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_
Output:
                   0: 0
                   5: 101
                  50: 110010
                9000: 10001100101000

Nim[edit]

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)

Output:

0
1
10
11
100
101
110
111
1000
1001
1010
1011
1100
1101
1110
1111

Oberon-2[edit]

 
MODULE BinaryDigits;
IMPORT Out;
 
PROCEDURE OutBin(x: INTEGER);
BEGIN
IF x > 1 THEN OutBin(x DIV 2) END;
Out.Int(x MOD 2, 1);
END OutBin;
 
 
BEGIN
OutBin(0); Out.Ln;
OutBin(1); Out.Ln;
OutBin(2); Out.Ln;
OutBin(3); Out.Ln;
OutBin(42); Out.Ln;
END BinaryDigits.
 
Output:
0
1
10
11
101010

Objeck[edit]

 
bundle Default {
class Binary {
function : Main(args : String[]) ~ Nil {
5->ToBinaryString()->PrintLine();
50->ToBinaryString()->PrintLine();
9000->ToBinaryString()->PrintLine();
}
}
}
 

OCaml[edit]

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)

Oforth[edit]

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[edit]

The Assembly code uses block structures to minimise the use of labels.

 
 
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
 

PARI/GP[edit]

bin(n:int)=concat(apply(s->Str(s),binary(n)))

Panda[edit]

0..15.radix:2 nl

output:

0 
1 
10 
11 
100 
101 
110 
111 
1000 
1001 
1010 
1011 
1100 
1101 
1110 
1111

Pascal[edit]

Works with: Free Pascal

FPC compiler Version 2.6 upwards.The obvious version.

program IntToBinTest;
{$MODE objFPC}
uses
strutils;//IntToBin
function WholeIntToBin(n: NativeUInt):string;
var
digits: NativeInt;
begin
// BSR?Word -> index of highest set bit but 0 -> 255 ==-1 )
IF n <> 0 then
Begin
{$ifdef CPU64}
digits:= BSRQWord(NativeInt(n))+1;
{$ELSE}
digits:= BSRDWord(NativeInt(n))+1;
{$ENDIF}
WholeIntToBin := IntToBin(NativeInt(n),digits);
end
else
WholeIntToBin:='0';
end;
procedure IntBinTest(n: NativeUint);
Begin
writeln(n:12,' ',WholeIntToBin(n));
end;
BEGIN
IntBinTest(5);IntBinTest(50);IntBinTest(5000);
IntBinTest(0);IntBinTest(NativeUint(-1));
end.

Output:

           5 101
          50 110010
        5000 1001110001000
           0 0
18446744073709551615 1111111111111111111111111111111111111111111111111111111111111111

alternative 4 chars at a time[edit]

using pchar like C insert one nibble at a time. Beware of the endianess of the constant. I check performance with random Data.

 
program IntToPcharTest;
uses
sysutils;//for timing
 
const
{$ifdef CPU64}
cBitcnt = 64;
{$ELSE}
cBitcnt = 32;
{$ENDIF}
 
procedure IntToBinPchar(AInt : NativeUInt;s:pChar);
//create the Bin-String
//!Beware of endianess ! this is for little endian
const
IO : array[0..1] of char = ('0','1');//('_','X'); as you like
IO4 : array[0..15] of LongWord = // '0000','1000' as LongWord
($30303030,$31303030,$30313030,$31313030,
$30303130,$31303130,$30313130,$31313130,
$30303031,$31303031,$30313031,$31313031,
$30303131,$31303131,$30313131,$31313131);
var
i : NativeInt;
 
begin
IF AInt > 0 then
Begin
// Get the index of highest set bit
{$ifdef CPU64}
i := BSRQWord(NativeInt(Aint))+1;
{$ELSE}
i := BSRDWord(NativeInt(Aint))+1;
{$ENDIF}
s[i] := #0;
//get 4 characters at once
dec(i);
while i >= 3 do
Begin
pLongInt(@s[i-3])^ := IO4[Aint AND 15];
Aint := Aint SHR 4;
dec(i,4)
end;
//the rest one by one
while i >= 0 do
Begin
s[i] := IO[Aint AND 1];
AInt := Aint shr 1;
dec(i);
end;
end
else
Begin
s[0] := IO[0];
s[1] := #0;
end;
end;
 
procedure Binary_Digits;
var
s: pCHar;
begin
GetMem(s,cBitcnt+4);
fillchar(s[0],cBitcnt+4,#0);
IntToBinPchar( 5,s);writeln(' 5: ',s);
IntToBinPchar( 50,s);writeln(' 50: ',s);
IntToBinPchar(9000,s);writeln('9000: ',s);
IntToBinPchar(NativeUInt(-1),s);writeln(' -1: ',s);
FreeMem(s);
end;
 
const
rounds = 10*1000*1000;
 
var
s: pChar;
t :TDateTime;
i,l,cnt: NativeInt;
Testfield : array[0..rounds-1] of NativeUint;
Begin
randomize;
cnt := 0;
For i := rounds downto 1 do
Begin
l := random(High(NativeInt));
Testfield[i] := l;
{$ifdef CPU64}
inc(cnt,BSRQWord(l));
{$ELSE}
inc(cnt,BSRQWord(l));
{$ENDIF}
end;
Binary_Digits;
GetMem(s,cBitcnt+4);
fillchar(s[0],cBitcnt+4,#0);
//warm up
For i := 0 to rounds-1 do
IntToBinPchar(Testfield[i],s);
//speed test
t := time;
For i := 1 to rounds do
IntToBinPchar(Testfield[i],s);
t := time-t;
Write(' Time ',t*86400.0:6:3,' secs, average stringlength ');
Writeln(cnt/rounds+1:6:3);
FreeMem(s);
end.

output:

//32-Bit fpc 3.1.1 -O3 -XX -Xs  Cpu i4330 @3.5 Ghz
   5: 101
  50: 110010
9000: 10001100101000
  -1: 11111111111111111111111111111111
 Time  0.133 secs, average stringlength 30.000
  //64-Bit fpc 3.1.1 -O3 -XX -Xs
...
  -1: 1111111111111111111111111111111111111111111111111111111111111111
 Time  0.175 secs, average stringlength 62.000
..the obvious version takes about 1.1 secs generating the string takes most of the time..

Peloton[edit]

<@ defbaslit>2</@>
 
<@ saybaslit>0</@>
<@ saybaslit>5</@>
<@ saybaslit>50</@>
<@ saybaslit>9000</@>
 

Perl[edit]

for (5, 50, 9000) {
printf "%b\n", $_;
}
101
110010
10001100101000

Perl 6[edit]

Works with: Rakudo version 2015.12
say .fmt("%b") for 5, 50, 9000;
101
110010
10001100101000

Phix[edit]

printf(1,"%b\n",5)
printf(1,"%b\n",50)
printf(1,"%b\n",9000)
Output:
101
110010
10001100101000

PHP[edit]

<?php
echo decbin(5);
echo decbin(50);
echo decbin(9000);

Output:

101
110010
10001100101000

PicoLisp[edit]

: (bin 5)
-> "101"
 
: (bin 50)
-> "110010"
 
: (bin 9000)
-> "10001100101000"

Piet[edit]

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[edit]

Displays binary output trivially, but with leading zeros:

put edit (25) (B);
Output: 0011001

With leading zero suppression:

   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'));
Output:
11001
1111111111111111111111111111111

PowerShell[edit]

@(5,50,900) | foreach-object { [Convert]::ToString($_,2) }

Output:

101
110010
1110000100

Prolog[edit]

Works with: SWI Prolog
Works with: GNU Prolog
 
binary(X) :- format('~2r~n', [X]).
main :- maplist(binary, [5,50,9000]), halt.
 
Sample output:
101
110010
10001100101000

PureBasic[edit]

If OpenConsole()
PrintN(Bin(5)) ;101
PrintN(Bin(50)) ;110010
PrintN(Bin(9000)) ;10001100101000
 
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf

Sample output:

101
110010
10001100101000

Python[edit]

Works with: Python version 3.X and 2.6+
>>> 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
Works with: Python version 3.X and 2.6+
>>> for i in range(16): print(bin(i))
 
0b0
0b1
0b10
0b11
0b100
0b101
0b110
0b111
0b1000
0b1001
0b1010
0b1011
0b1100
0b1101
0b1110
0b1111

Pre-Python 2.6:

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

Racket[edit]

 
#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)))
 

Retro[edit]

9000 50 5  3 [ binary putn cr decimal ] times

REXX[edit]

This version handles the special case of zero simply.

simple version[edit]

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 superfluous leading zero suppression).

/*REXX program to  convert  several  decimal numbers  to  binary  (or base 2).          */
numeric digits 1000 /*ensure we can handle larger numbers. */
@.=; @.1= 0
@.2= 5
@.3= 50
@.4= 9000
 
do j=1 while @.j\=='' /*compute until a NULL value is found.*/
y=x2b( d2x(@.j) ) + 0 /*force removal of extra leading zeroes*/
say right(@.j,20) 'decimal, and in binary:' y /*display the number to the terminal. */
end /*j*/ /*stick a fork in it, we're all done. */

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[edit]

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.

/*REXX program to  convert  several  decimal numbers  to  binary  (or base 2).          */
@.=; @.1= 0
@.2= 5
@.3= 50
@.4= 9000
 
do j=1 while @.j\=='' /*compute until a NULL value is found.*/
y=strip( x2b( d2x( @.j )), 'L', 0) /*force removal of all leading zeroes.*/
if y=='' then y=0 /*handle the special case of 0 (zero).*/
say right(@.j,20) 'decimal, and in binary:' y /*display the number to the terminal. */
end /*j*/ /*stick a fork in it, we're all done. */

output is identical to the 1st REXX version.

concise version[edit]

This version handles the case of zero a bit more obtusely, but concisely.

/*REXX program to  convert  several  decimal numbers  to  binary  (or base 2).          */
@.=; @.1= 0
@.2= 5
@.3= 50
@.4= 9000
 
do j=1 while @.j\=='' /*compute until a NULL value is found.*/
y=word( strip( x2b( d2x( @.j )), 'L', 0) 0, 1) /*elides all leading 0s, if null, use 0*/
say right(@.j,20) 'decimal, and in binary:' y /*display the number to the terminal. */
end /*j*/ /*stick a fork in it, we're all done. */

output is identical to the 1st REXX version.

conforming version[edit]

This REXX version conforms to the strict output requirements of this task (just show the binary output without any blanks).

/*REXX program to  convert  several  decimal numbers  to  binary  (or base 2).          */
numeric digits 200 /*ensure we can handle larger numbers. */
@.=; @.1= 0
@.2= 5
@.3= 50
@.4= 9000
@.5=423785674235000123456789
@.6= 1e138 /*one quinquaquadragintillion ugh.*/
 
do j=1 while @.j\=='' /*compute until a NULL value is found.*/
y=strip( x2b( d2x( @.j )), 'L', 0) /*force removal of all leading zeroes.*/
if y=='' then y=0 /*handle the special case of 0 (zero).*/
say right(@.j,20) 'decimal, and in binary:' y /*display the number to the terminal. */
end /*j*/ /*stick a fork in it, we're all done. */

output

0
101
110010
10001100101000
1011001101111010111011110101001101111000000000000110001100000100111110100010101
101010111111101001000101110110100000111011011011110111100110100100000100100001111101101110011101000101110110001101101000100100100110000111001010101011110010001111100011110100010101011011111111000110101110111100001011100111110000000010101100110101001010001001001011000000110000010010010100010010000001110100101000011111001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Ring[edit]

 
see "Number to convert : "
give a
n = 0
while pow(2,n+1) < a
n = n + 1
end
 
for i = n to 0 step -1
x = pow(2,i)
if a >= x see 1 a = a - x
else see 0 ok
next
 

Ruby[edit]

[5,50,9000].each do |n|
puts "%b" % n
end

or

for n in [5,50,9000]
puts n.to_s(2)
end

Output:

101
110010
10001100101000

Run BASIC[edit]

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

Output:

Number to convert:?9000
10001100101000

Rust[edit]

fn main() {
for i in 0..8 {
println!("{:b}", i)
}
}

Outputs:

0
1
10
11
100
101
110
111


S-lang[edit]

define int_to_bin(d)
{
variable m = 0x40000000, prn = 0, bs = "";
do {
if (d & m) {
bs += "1";
prn = 1;
}
else if (prn)
bs += "0";
m = m shr 1;
 
} while (m);
 
if (bs == "") bs = "0";
return bs;
}
 
() = printf("%s\n", int_to_bin(5));
() = printf("%s\n", int_to_bin(50));
() = printf("%s\n", int_to_bin(9000));
Output:
101
110010
10001100101000

Scala[edit]

Scala has an implicit conversion from Int to RichInt which has a method toBinaryString.

scala> (5 toBinaryString)
res0: String = 101
 
scala> (50 toBinaryString)
res1: String = 110010
 
scala> (9000 toBinaryString)
res2: String = 10001100101000

Scheme[edit]

(display (number->string 5 2)) (newline)
(display (number->string 50 2)) (newline)
(display (number->string 9000 2)) (newline)

Seed7[edit]

This example uses the radix operator to write a number in binary.

$ 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;

Output:

0
1
10
11
100
101
110
111
1000
1001
1010
1011
1100
1101
1110
1111
10000

Sidef[edit]

[5, 50, 9000].each { |n|
say n.as_bin;
}
Output:
101
110010
10001100101000

SequenceL[edit]

main := toBinaryString([5, 50, 9000]);
 
toBinaryString(number(0)) :=
let
val := "1" when number mod 2 = 1 else "0";
in
toBinaryString(floor(number/2)) ++ val when floor(number/2) > 0
else
val;
Output:
["101","110010","10001100101000"]

Smalltalk[edit]

5 printOn: Stdout radix:2
50 printOn: Stdout radix:2
9000 printOn: Stdout radix:2

or:

#(5 50 9000) do:[:each | each printOn: Stdout radix:2. Stdout cr]

SNUSP[edit]

 
/recurse\
$,binary!\@\>?!\@/<@\.#
 ! \=/ \=itoa=@@@+@+++++#
/<+>- \ div2
\?!#-?/+# mod2
 

Standard ML[edit]

print (Int.fmt StringCvt.BIN 5 ^ "\n");
print (Int.fmt StringCvt.BIN 50 ^ "\n");
print (Int.fmt StringCvt.BIN 9000 ^ "\n");

Swift[edit]

for num in [5, 50, 9000] {
println(String(num, radix: 2))
}
Output:
101
110010
10001100101000

Tcl[edit]

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"
}

Demonstrating:

for {set x 0} {$x < 16} {incr x} {
puts [num2bin $x]
}
puts "--------------"
puts [num2bin 5]
puts [num2bin 50]
puts [num2bin 9000]

Output:

0
1
10
11
100
101
110
111
1000
1001
1010
1011
1100
1101
1110
1111
--------------
101
110010
10001100101000

TI-83 BASIC[edit]

Using Standard TI-83 BASIC

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

Alternate using a string to display larger numbers.

PROGRAM:BINARY
:Input X
:" "→Str1
:Repeat X=0
 :X/2→X
 :sub("01",2fPart(X)+1,1)+Str1→Str1
 :iPart(X)→X
:End
:Str1

Using the baseInput() "real(25," function from Omnicalc

PROGRAM:BINARY
:Disp "NUMBER TO"
:Disp "CONVERT"
:Input "Str1"
:Disp real(25,Str1,10,2)

More compact version:

: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
 

uBasic/4tH[edit]

This will convert any decimal number to any base between 2 and 16.

Do
Input "Enter base (1<X<17): "; b
While (b < 2) + (b > 16)
Loop
 
Input "Enter number: "; n
s = (n < 0) ' save the sign
n = Abs(n) ' make number unsigned
 
For x = 0 Step 1 Until n = 0 ' calculate all the digits
@(x) = n % b
n = n / b
Next x
 
If s Then Print "-"; ' reapply the sign
 
For y = x - 1 To 0 Step -1 ' print all the digits
If @(y) > 9 Then ' take care of hexadecimal digits
Gosub @(y) * 10
Else
Print @(y); ' print "decimal" digits
Endif
Next y
 
Print ' finish the string
End
 
100 Print "A"; : Return ' print hexadecimal digit
110 Print "B"; : Return
120 Print "C"; : Return
130 Print "D"; : Return
140 Print "E"; : Return
150 Print "F"; : Return
Output:
Enter base (1<X<17): 2
Enter number: 9000
10001100101000

0 OK, 0:775

UNIX Shell[edit]

# 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

Vedit macro language[edit]

This implementation reads the numeric values from user input and writes the converted binary values in the edit buffer.

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

Example output when values 0, 1, 5, 50 and 9000 were entered:

0
1
101
110010
10001100101000

Vim Script[edit]

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)
Output:
101                                                                             
110010                                                                          
10001100101000

Visual Basic .NET[edit]

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

Output:

5: 101
50: 110010
9000: 10001100101000

Visual FoxPro[edit]

 
*!* 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
 
Output:
101
110010
10001100101000

Whitespace[edit]

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.

    
 



 







 










 
 








 


 
 

It was generated from the following pseudo-Assembly.

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

Wortel[edit]

Using JavaScripts buildin toString method on the Number object, the following function takes a number and returns a string with the binary representation:

\.toString 2
; the following function also casts the string to a number
^(@+ \.toString 2)

To output to the console:

@each ^(console.log \.toString 2) [5 50 900]
Outputs:
101
110010
1110000100

X86 Assembly[edit]

Translation of XPL0. Assemble with tasm, tlink /t

        .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

Output:

101
110010
10001100101000

XPL0[edit]

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;
]

Example output:

0
1
10
11
100
101
110
111
1000
...
100000010011110
100000010011111
100000010100000
100000010100001

zkl[edit]

(9000).toString(2)
T(5,50,9000).apply("toString",2) //--> L("101","110010","10001100101000")
"%.2B".fmt(9000)

ZX Spectrum Basic[edit]

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