Binary digits: Difference between revisions
PascalABC.NET
No edit summary |
(PascalABC.NET) |
||
| (225 intermediate revisions by 83 users not shown) | |||
Line 1:
[[Category:Radices]]
{{task|Basic language learning}}
;Task:
Line 15:
There should be no other whitespace, radix or sign markers in the produced output, and [[wp:Leading zero|leading zeros]] should not appear in the results.
<br><br>
=={{header|8th}}==
<syntaxhighlight lang="forth">
2 base drop
#50 . cr
</syntaxhighlight>
{{out}}
<pre>
110010
</pre>
=={{header|11l}}==
<syntaxhighlight lang="11l">L(n) [0, 5, 50, 9000]
print(‘#4 = #.’.format(n, bin(n)))</syntaxhighlight>
{{out}}
<pre>
0 = 0
5 = 101
50 = 110010
9000 = 10001100101000
</pre>
=={{header|360 Assembly}}==
<
BINARY CSECT
USING BINARY,R12
Line 82 ⟶ 77:
CBIN DC CL32' ' binary value
YREGS
END BINARY</
{{out}}
<pre>
Line 90 ⟶ 85:
9000 10001100101000
</pre>
=={{header|0815}}==
<syntaxhighlight 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:</syntaxhighlight>
{{out}}
Note that 0815 reads numeric input in hexadecimal.
<syntaxhighlight lang="bash">echo -e "5\n32\n2329" | 0815 bin.0
101
110010
10001100101001</syntaxhighlight>
=={{header|6502 Assembly}}==
{{works with|http://vice-emu.sourceforge.net/ VICE}}
Line 111 ⟶ 127:
strout = $cb1e
</pre>
<
; C64 - Binary digits
; http://rosettacode.org/wiki/Binary_digits
Line 202 ⟶ 218:
binstr .repeat 16, $00 ; reserve 16 bytes for the binary digits
.byte $0d, $00 ; newline + null terminator
</syntaxhighlight>
{{out}}
<pre>
SYS828,5
Line 217 ⟶ 233:
100
</pre>
=={{header|8080 Assembly}}==
<syntaxhighlight lang="8080asm">bdos: equ 5h ; CP/M system call
puts: equ 9h ; Print string
org 100h
lxi h,5 ; Print value for 5
call prbin
lxi h,50 ; Print value for 50
call prbin
lxi h,9000 ; Print value for 9000
prbin: call bindgt ; Make binary representation of HL
mvi c,puts ; Print it
jmp bdos
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Return the binary representation of the 16-bit number in HL
;;; as a string starting at [DE].
bindgt: lxi d,binend ; End of binary string
ana a ; Clear carry flag
binlp: dcx d ; Previous digit
mov a,h ; Shift HL left, LSB into carry flag
rar
mov h,a
mov a,l
rar
mov l,a
mvi a,'0' ; Digit '0' or '1' depending on
aci 0 ; status of carry flag.
stax d
mov a,h ; Is HL 0 now?
ora l
rz ; Then stop
jmp binlp ; Otherwise, do next bit
binstr: db '0000000000000000' ; Placeholder for string
binend: db 13,10,'$' ; end with \r\n </syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000
</pre>
=={{header|8086 Assembly}}==
<syntaxhighlight lang="asm"> .model small
.stack 1024
.data
TestData0 byte 5,255 ;255 is the terminator
TestData1 byte 5,0,255
TestData2 byte 9,0,0,0,255
.code
start:
mov ax,@data
mov ds,ax
cld ;String functions are set to auto-increment
mov ax,2 ;clear screen by setting video mode to 0
int 10h ;select text mode - We're already in it, so this clears the screen
mov si,offset TestData0
call PrintBinary_NoLeadingZeroes
mov si,offset TestData1
call PrintBinary_NoLeadingZeroes
mov si,offset TestData2
call PrintBinary_NoLeadingZeroes
ExitDOS:
mov ax,4C00h ;return to dos
int 21h
PrintBinary_NoLeadingZeroes proc
;input: DS:SI = seg:offset of a 255-terminated sequence of unpacked BCD digits, stored big-endian
;setup
mov bx,8000h
;bl will be our "can we print zeroes yet" flag.
;bh is the "revolving bit mask" - we'll compare each bit to it, then rotate it right once.
; It's very handy because it's a self-resetting loop counter as well!
NextDigit:
lodsb
cmp al,255
je Terminated
NextBit:
test al,bh ;is the bit we're testing right now set?
jz PrintZero
;else, print one
push ax
mov dl,'1' ;31h
mov ah,2
int 21h ;prints the ascii code in DL
pop ax
or bl,1 ;set "we've printed a one" flag
jmp predicate
PrintZero:
test bl,bl
jz predicate
push ax
mov dl,'0' ;30h
mov ah,2
int 21h
pop ax
predicate:
ror bh,1
jnc NextBit
;if the carry is set, we've rotated BH back to 10000000b,
; so move on to the next digit in that case.
jmp NextDigit
Terminated:
push ax
mov ah,2
mov dl,13 ;carriage return
int 21h
mov dl,10 ;linefeed
int 21h
pop ax
ret
PrintBinary_NoLeadingZeroes endp</syntaxhighlight>
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program binarydigit.s */
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
/*******************************************/
/* Initialized data */
/*******************************************/
.data
sMessAffBindeb: .asciz "The decimal value "
sMessAffBin: .asciz " should produce an output of "
szRetourLigne: .asciz "\n"
/*******************************************/
/* Uninitialized data */
/*******************************************/
.bss
sZoneConv: .skip 100
sZoneBin: .skip 100
/*******************************************/
/* code section */
/*******************************************/
.text
.global main
main: /* entry of program */
mov x5,5
mov x0,x5
ldr x1,qAdrsZoneConv
bl conversion10S
mov x0,x5
ldr x1,qAdrsZoneBin
bl conversion2 // binary conversion and display résult
ldr x0,qAdrsZoneBin
ldr x0,qAdrsMessAffBindeb
bl affichageMess
ldr x0,qAdrsZoneConv
bl affichageMess
ldr x0,qAdrsMessAffBin
bl affichageMess
ldr x0,qAdrsZoneBin
bl affichageMess
ldr x0,qAdrszRetourLigne
bl affichageMess
/* other number */
mov x5,50
mov x0,x5
ldr x1,qAdrsZoneConv
bl conversion10S
mov x0,x5
ldr x1,qAdrsZoneBin
bl conversion2 // binary conversion and display résult
ldr x0,qAdrsZoneBin
ldr x0,qAdrsMessAffBindeb
bl affichageMess
ldr x0,qAdrsZoneConv
bl affichageMess
ldr x0,qAdrsMessAffBin
bl affichageMess
ldr x0,qAdrsZoneBin
bl affichageMess
ldr x0,qAdrszRetourLigne
bl affichageMess
/* other number */
mov x5,-1
mov x0,x5
ldr x1,qAdrsZoneConv
bl conversion10S
mov x0,x5
ldr x1,qAdrsZoneBin
bl conversion2 // binary conversion and display résult
ldr x0,qAdrsZoneBin
ldr x0,qAdrsMessAffBindeb
bl affichageMess
ldr x0,qAdrsZoneConv
bl affichageMess
ldr x0,qAdrsMessAffBin
bl affichageMess
ldr x0,qAdrsZoneBin
bl affichageMess
ldr x0,qAdrszRetourLigne
bl affichageMess
/* other number */
mov x5,1
mov x0,x5
ldr x1,qAdrsZoneConv
bl conversion10S
mov x0,x5
ldr x1,qAdrsZoneBin
bl conversion2 // binary conversion and display résult
ldr x0,qAdrsZoneBin
ldr x0,qAdrsMessAffBindeb
bl affichageMess
ldr x0,qAdrsZoneConv
bl affichageMess
ldr x0,qAdrsMessAffBin
bl affichageMess
ldr x0,qAdrsZoneBin
bl affichageMess
ldr x0,qAdrszRetourLigne
bl affichageMess
100: // standard end of the program */
mov x0, #0 // return code
mov x8, #EXIT // request to exit program
svc 0 // perform the system call
qAdrsZoneConv: .quad sZoneConv
qAdrsZoneBin: .quad sZoneBin
qAdrsMessAffBin: .quad sMessAffBin
qAdrsMessAffBindeb: .quad sMessAffBindeb
qAdrszRetourLigne: .quad szRetourLigne
/******************************************************************/
/* register conversion in binary */
/******************************************************************/
/* x0 contains the register */
/* x1 contains the address of receipt area */
conversion2:
stp x2,lr,[sp,-16]! // save registers
stp x3,x4,[sp,-16]! // save registers
clz x2,x0 // number of left zeros bits
mov x3,64
sub x2,x3,x2 // number of significant bits
strb wzr,[x1,x2] // store 0 final
sub x3,x2,1 // position counter of the written character
2: // loop
tst x0,1 // test first bit
lsr x0,x0,#1 // shift right one bit
bne 3f
mov x4,#48 // bit = 0 => character '0'
b 4f
3:
mov x4,#49 // bit = 1 => character '1'
4:
strb w4,[x1,x3] // character in reception area at position counter
sub x3,x3,#1
subs x2,x2,#1 // 0 bits ?
bgt 2b // no! loop
100:
ldp x3,x4,[sp],16 // restaur 2 registres
ldp x2,lr,[sp],16 // restaur 2 registres
ret // retour adresse lr x30
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
{{out}}
<pre>
The decimal value +5 should produce an output of 101
The decimal value +50 should produce an output of 110010
The decimal value -1 should produce an output of 1111111111111111111111111111111111111111111111111111111111111111
The decimal value +1 should produce an output of 1
</pre>
=={{header|ACL2}}==
<
(defun bin-string-r (x)
Line 242 ⟶ 539:
(if (zp x)
"0"
(bin-string-r x)))</
=={{header|Action!}}==
<syntaxhighlight lang="action!">PROC PrintBinary(CARD v)
CHAR ARRAY a(16)
BYTE i=[0]
DO
a(i)=(v&1)+'0
i==+1
v=v RSH 1
UNTIL v=0
OD
DO
i==-1
Put(a(i))
UNTIL i=0
OD
RETURN
PROC Main()
CARD ARRAY data=[0 5 50 9000]
BYTE i
CARD v
FOR i=0 TO 3
DO
v=data(i)
PrintF("Output for %I is ",v)
PrintBinary(v)
PutE()
OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Binary_digits.png Screenshot from Atari 8-bit computer]
<pre>
Output for 0 is 0
Output for 5 is 101
Output for 50 is 110010
Output for 9000 is 10001100101000
</pre>
=={{header|Ada}}==
<syntaxhighlight lang="ada">with ada.text_io; use ada.text_io;
procedure binary is
bit : array (0..1) of character := ('0','1');
function bin_image (n : Natural) return string is
(if n < 2 then (1 => bit (n)) else bin_image (n / 2) & bit (n mod 2));
test_values : array (1..3) of Natural := (5,50,9000);
begin
for test of test_values loop
put_line ("Output for" & test'img & " is " & bin_image (test));
end loop;
end
{{out}}
<pre>
Output for 5 is 101
Output for 50 is 110010
Output for 9000 is 10001100101000
</pre>
=={{header|Aime}}==
<
o_byte('\n');
o_xinteger(2, 5);
Line 269 ⟶ 609:
o_xinteger(2, 50);
o_byte('\n');
o_form("/x2/\n", 9000);</
{{out}}
<pre>0
Line 275 ⟶ 615:
110010
10001100101000</pre>
=={{header|ALGOL 68}}==
{{works with|ALGOL 68|Revision 1.}}
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.3.3 algol68g-2.3.3].}}
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to use of '''format'''[ted] ''transput''.}}
'''File: Binary_digits.a68'''<
printf((
Line 293 ⟶ 632:
50, " => ", []BOOL(BIN 50)[bits width-6+1:], new line,
9000, " => ", []BOOL(BIN 9000)[bits width-14+1:], new line
))</
{{out}}
<pre>
+5 => 101
Line 303 ⟶ 642:
+9000 => TFFFTTFFTFTFFF
</pre>
=={{header|ALGOL W}}==
<
% prints an integer in binary - the number must be greater than zero %
procedure printBinaryDigits( integer value n ) ;
Line 328 ⟶ 666:
end
end.</
=={{header|ALGOL-M}}==
<syntaxhighlight lang="algolm">begin
procedure writebin(n);
integer n;
begin
procedure inner(x);
integer x;
begin
if x>1 then inner(x/2);
writeon(if x-x/2*2=0 then "0" else "1");
end;
write(""); % start new line %
inner(n);
end;
writebin(5);
writebin(50);
writebin(9000);
end</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|APL}}==
Works in: [[Dyalog APL]]
A builtin function. Produces a boolean array.
<syntaxhighlight lang="apl">base2←2∘⊥⍣¯1</syntaxhighlight>
Works in: [[GNU APL]]
Produces a boolean array.
<syntaxhighlight lang="apl">base2 ← {((⌈2⍟⍵+1)⍴2)⊤⍵}</syntaxhighlight>
NOTE: Both versions above will yield an empty boolean array for 0.
<pre>
base2 0
base2 5
1 0 1
base2 50
1 1 0 0 1 0
base2 9000
1 0 0 0 1 1 0 0 1 0 1 0 0 0
</pre>
=={{header|AppleScript}}==
===Functional===
{{Trans|JavaScript}}
(ES6 version)
(The generic showIntAtBase here, which allows us to specify the digit set used (e.g. upper or lower case in hex, or different regional or other digit sets generally), is a rough translation of Haskell's Numeric.showintAtBase)
<syntaxhighlight lang="applescript">---------------------- BINARY STRING -----------------------
on
script binaryChar
text item (n + 1) of "01"
end |λ|
end script
showIntAtBase(2, binaryChar, n, "")
end showBin
--------------------------- TEST ---------------------------
on run
script
on |λ|(n)
intercalate(" -> ", {n as string, showBin(n)})
end |λ|
end script
return unlines(map(result, {5, 50, 9000}))
end run
-------------------- GENERIC FUNCTIONS ---------------------
-- showIntAtBase :: Int -> (Int -> Char) -> Int -> String -> String
on showIntAtBase(base, toChr, n, rs)
set
set
if
else
end if
end
end script
if base ≤ 1
"error: showIntAtBase applied to unsupported base: " & base as string
else if n < 0
"error: showIntAtBase applied to negative number: " & base as string
else
end if
end showIntAtBase
-- quotRem :: Integral a => a -> a -> (a, a)
on quotRem(m, n)
{m div n, m mod n}
end quotRem
-------------------- GENERICS FOR TEST ---------------------
-- 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
-- map :: (a -> b) -> [a] -> [b]
Line 390 ⟶ 794:
set lst to {}
repeat with i from 1 to lng
set end of lst to
end repeat
return lst
Line 396 ⟶ 800:
end map
-- Lift 2nd class handler function into 1st class script wrapper
Line 411 ⟶ 808:
else
script
property
end script
end if
end mReturn
-- unlines :: [String] -> String
on unlines(xs)
intercalate(linefeed, xs)
end unlines</syntaxhighlight>
<pre>5 -> 101
50 -> 110010
9000 -> 10001100101000</pre>
Or using:
<syntaxhighlight lang="applescript">-- showBin :: Int -> String
on showBin(n)
script binaryChar
on |λ|(n)
text item (n + 1) of "〇一"
end |λ|
end script
showIntAtBase(2, binaryChar, n, "")
end showBin</syntaxhighlight>
{{Out}}
<pre>
50 -> 一一〇〇一〇
9000 -> 一〇〇〇一一〇〇一〇一〇〇〇</pre>
=== Straightforward ===
At its very simplest, an AppleScript solution would look something like this:
<syntaxhighlight lang="applescript">on intToBinary(n)
set binary to ((n mod 2 div 1) as text) & binary
set n to n div 2
end repeat
return binary
end intToBinary
display dialog ¬
intToBinary(5) & linefeed & ¬
intToBinary(50) & linefeed & ¬
intToBinary(9000) & linefeed</syntaxhighlight>
Building a list of single-digit values instead and coercing that at the end can be a tad faster, but execution can be four or five times as fast when groups of text (or list) operations are replaced with arithmetic:
<syntaxhighlight lang="applescript">on intToBinary(n)
set binary to ""
repeat
-- Calculate an integer value whose 8 decimal digits are the same as the low 8 binary digits of n's current value.
set binAsDec to (n div 128 mod 2 * 10000000 + n div 64 mod 2 * 1000000 + n div 32 mod 2 * 100000 + ¬
n div 16 mod 2 * 10000 + n div 8 mod 2 * 1000 + n div 4 mod 2 * 100 + n div 2 mod 2 * 10 + n mod 2) div 1
-- Coerce to text as appropriate, prepend to the output text, and prepare to get another 8 digits or not as necessary.
if (n > 255) then
set binary to text 2 thru -1 of ((100000000 + binAsDec) as text) & binary
set n to n div 256
else
set binary to (binAsDec as text) & binary
exit repeat
end if
end repeat
return binary
end intToBinary
display dialog ¬
intToBinary(5) & linefeed & ¬
intToBinary(50) & linefeed & ¬
intToBinary(9000) & linefeed</syntaxhighlight>
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program binarydigit.s */
/* Constantes */
.equ STDOUT, 1
.equ WRITE, 4
.equ EXIT, 1
/* Initialized data */
.data
sMessAffBin: .ascii "The decimal value "
sZoneDec: .space 12,' '
.ascii " should produce an output of "
sZoneBin: .space 36,' '
.asciz "\n"
/* code section */
.text
.global main
main: /* entry of program */
push {fp,lr} /* save des 2 registres */
mov r0,#5
ldr r1,iAdrsZoneDec
bl conversion10S @ decimal conversion
bl conversion2 @ binary conversion and display résult
mov r0,#50
ldr r1,iAdrsZoneDec
bl conversion10S
bl conversion2
mov r0,#-1
ldr r1,iAdrsZoneDec
bl conversion10S
bl conversion2
mov r0,#1
ldr r1,iAdrsZoneDec
bl conversion10S
bl conversion2
100: /* standard end of the program */
mov r0, #0 @ return code
pop {fp,lr} @restaur 2 registers
mov r7, #EXIT @ request to exit program
swi 0 @ perform the system call
iAdrsZoneDec: .int sZoneDec
/******************************************************************/
/* register conversion in binary */
/******************************************************************/
/* r0 contains the register */
conversion2:
push {r0,lr} /* save registers */
push {r1-r5} /* save others registers */
ldr r1,iAdrsZoneBin @ address reception area
clz r2,r0 @ number of left zeros bits
rsb r2,#32 @ number of significant bits
mov r4,#' ' @ space
add r3,r2,#1 @ position counter in reception area
1:
strb r4,[r1,r3] @ space in other location of reception area
add r3,#1
cmp r3,#32 @ end of area ?
ble 1b @ no! loop
mov r3,r2 @ position counter of the written character
2: @ loop
lsrs r0,#1 @ shift right one bit with flags
movcc r4,#48 @ carry clear => character 0
movcs r4,#49 @ carry set => character 1
strb r4,[r1,r3] @ character in reception area at position counter
sub r3,r3,#1 @
subs r2,r2,#1 @ 0 bits ?
bgt 2b @ no! loop
ldr r0,iAdrsZoneMessBin
bl affichageMess
100:
pop {r1-r5} /* restaur others registers */
pop {r0,lr}
bx lr
iAdrsZoneBin: .int sZoneBin
iAdrsZoneMessBin: .int sMessAffBin
/******************************************************************/
/* display text with size calculation */
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
push {fp,lr} /* save registres */
push {r0,r1,r2,r7} /* save others registres */
mov r2,#0 /* counter length */
1: /* loop length calculation */
ldrb r1,[r0,r2] /* read octet start position + index */
cmp r1,#0 /* if 0 its over */
addne r2,r2,#1 /* else add 1 in the length */
bne 1b /* and loop */
/* so here r2 contains the length of the message */
mov r1,r0 /* address message in r1 */
mov r0,#STDOUT /* code to write to the standard output Linux */
mov r7, #WRITE /* code call system "write" */
swi #0 /* call systeme */
pop {r0,r1,r2,r7} /* restaur others registres */
pop {fp,lr} /* restaur des 2 registres */
bx lr /* return */
/***************************************************/
/* conversion registre en décimal signé */
/***************************************************/
/* r0 contient le registre */
/* r1 contient l adresse de la zone de conversion */
conversion10S:
push {fp,lr} /* save des 2 registres frame et retour */
push {r0-r5} /* save autres registres */
mov r2,r1 /* debut zone stockage */
mov r5,#'+' /* par defaut le signe est + */
cmp r0,#0 /* nombre négatif ? */
movlt r5,#'-' /* oui le signe est - */
mvnlt r0,r0 /* et inversion en valeur positive */
addlt r0,#1
mov r4,#10 /* longueur de la zone */
1: /* debut de boucle de conversion */
bl divisionpar10 /* division */
add r1,#48 /* ajout de 48 au reste pour conversion ascii */
strb r1,[r2,r4] /* stockage du byte en début de zone r5 + la position r4 */
sub r4,r4,#1 /* position précedente */
cmp r0,#0
bne 1b /* boucle si quotient different de zéro */
strb r5,[r2,r4] /* stockage du signe à la position courante */
subs r4,r4,#1 /* position précedente */
blt 100f /* si r4 < 0 fin */
/* sinon il faut completer le debut de la zone avec des blancs */
mov r3,#' ' /* caractere espace */
2:
strb r3,[r2,r4] /* stockage du byte */
subs r4,r4,#1 /* position précedente */
bge 2b /* boucle si r4 plus grand ou egal a zero */
100: /* fin standard de la fonction */
pop {r0-r5} /*restaur des autres registres */
pop {fp,lr} /* restaur des 2 registres frame et retour */
bx lr
/***************************************************/
/* division par 10 signé */
/* Thanks to http://thinkingeek.com/arm-assembler-raspberry-pi/*
/* and http://www.hackersdelight.org/ */
/***************************************************/
/* r0 contient le dividende */
/* r0 retourne le quotient */
/* r1 retourne le reste */
divisionpar10:
/* r0 contains the argument to be divided by 10 */
push {r2-r4} /* save others registers */
mov r4,r0
ldr r3, .Ls_magic_number_10 /* r1 <- magic_number */
smull r1, r2, r3, r0 /* r1 <- Lower32Bits(r1*r0). r2 <- Upper32Bits(r1*r0) */
mov r2, r2, ASR #2 /* r2 <- r2 >> 2 */
mov r1, r0, LSR #31 /* r1 <- r0 >> 31 */
add r0, r2, r1 /* r0 <- r2 + r1 */
add r2,r0,r0, lsl #2 /* r2 <- r0 * 5 */
sub r1,r4,r2, lsl #1 /* r1 <- r4 - (r2 * 2) = r4 - (r0 * 10) */
pop {r2-r4}
bx lr /* leave function */
.align 4
.Ls_magic_number_10: .word 0x66666667
</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">print as.binary 5
print as.binary 50
print as.binary 9000</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|AutoHotkey}}==
<
MsgBox % NumberToBinary(50) ;110010
MsgBox % NumberToBinary(9000) ;10001100101000
Line 448 ⟶ 1,068:
Result := (InputNumber & 1) . Result, InputNumber >>= 1
Return, Result
}</
=={{header|AutoIt}}==
<
ConsoleWrite(IntToBin(50) & @CRLF)
Line 466 ⟶ 1,086:
Return $r
EndFunc ;==>IntToBin
</syntaxhighlight>
=={{header|AWK}}==
<
print tobinary(0)
print tobinary(1)
print tobinary(5)
print tobinary(50)
Line 476 ⟶ 1,098:
function tobinary(num) {
outstr =
return outstr
}</
=={{header|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.
<
.Axe supports 16-bit integers, so 16 digits are enough
L₁+16→P
Line 505 ⟶ 1,116:
End
Disp P,i
Return</
=={{header|BaCon}}==
<
OPTION MEMTYPE int
INPUT n$
Line 515 ⟶ 1,125:
ELSE
PRINT CHOP$(BIN$(VAL(n$)), "0", 1)
ENDIF</
=={{header|Bash}}==
<syntaxhighlight lang="bash">
function to_binary () {
if [ $1 -ge 0 ]
then
val=$1
binary_digits=()
while [ $val -gt 0 ]; do
bit=$((val % 2))
quotient=$((val / 2))
binary_digits+=("${bit}")
val=$quotient
echo "${binary_digits[*]}" | rev
else
}
array=(5 50 9000)
for number in "${array[@]}"; do
echo $number " :> " $(to_binary $number)
done
</syntaxhighlight>
{{out}}
<pre>
5 :> 1 0 1
50 :> 1 1 0 0 1 0
9000 :> 1 0 0 0 1 1 0 0 1 0 1 0 0 0
</pre>
=={{header|BASIC}}==
==={{header|Applesoft BASIC}}===
<syntaxhighlight lang="applesoftbasic"> 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</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000
</pre>
==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">
# DecToBin.bas
# BASIC256 1.1.4.0
dim a(3) #dimension a 3 element array (a)
a = {5, 50, 9000}
for i = 0 to 2
print a[i] + chr(9) + toRadix(a[i],2) # radix (decimal, base2)
next i
</syntaxhighlight>
{{out}}
<pre>
5 101
50 110010
9000 10001100101000
</pre>
==={{header|BBC BASIC}}===
<
PRINT FN_tobase(num%, 2, 0)
NEXT
Line 550 ⟶ 1,213:
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(50)
PRINT FNbinary(9000)
Line 564 ⟶ 1,227:
N% = N% >>> 1 : REM BBC Basic prior to V5 can use N% = N% DIV 2
UNTIL N% = 0
=A$</
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
<syntaxhighlight lang="qbasic">10 for c = 1 to 3
20 read n
30 print n;"-> ";vin$(n)
40 next c
80 end
100 sub vin$(n)
110 b$ = ""
120 n = abs(int(n))
130 '
140 b$ = str$(n mod 2)+b$
150 n = int(n/2)
160 if n > 0 then 130
170 vin$ = b$
180 end sub
200 data 5,50,9000</syntaxhighlight>
==={{header|Commodore BASIC}}===
Since the task only requires nonnegative integers, we use a negative one to signal the end of the demonstration data.
Note the <tt>FOR N1 =</tt> ... <tt>TO 0 STEP 0</tt> idiom; the zero step means that the variable is not modified by BASIC, so it's up to the code inside the loop to eventually set <tt>N1</tt> to 0 so that the loop terminates – like a C <tt>for</tt> loop with an empty third clause. After the initialization, it's essentially a "while N1 is not 0" loop, but Commodore BASIC originally didn't have <b>while</b> loops (<tt>DO WHILE</tt> ... <tt>LOOP</tt> was added in BASIC 3.5). The alternative would be a <tt>GOTO</tt>, but the <tt>FOR</tt> loop lends more structure.
<syntaxhighlight lang="gwbasic">10 READ N
20 IF N < 0 THEN 70
30 GOSUB 100
40 PRINT N"-> "B$
50 GOTO 10
60 DATA 5, 50, 9000, -1
70 END
90 REM *** SUBROUTINE: CONVERT INTEGER IN N TO BINARY STRING B$
100 B$=""
110 FOR N1 = ABS(INT(N)) TO 0 STEP 0
120 : B$ = MID$(STR$(N1 AND 1),2) + B$
130 : N1 = INT(N1/2)
140 NEXT N1
150 RETURN</syntaxhighlight>
{{Out}}
<pre>
5 -> 101
50 -> 110010
9000 -> 10001100101000
</pre>
==={{header|IS-BASIC}}===
<syntaxhighlight lang="is-basic">10 PRINT BIN$(50)
100 DEF BIN$(N)
110 LET N=ABS(INT(N)):LET B$=""
120 DO
140 LET B$=STR$(MOD(N,2))&B$:LET N=INT(N/2)
150 LOOP WHILE N>0
160 LET BIN$=B$
170 END DEF</syntaxhighlight>
==={{header|QBasic}}===
<syntaxhighlight lang="qbasic">FUNCTION BIN$ (N)
N = ABS(INT(N))
B$ = ""
DO
B$ = STR$(N MOD 2) + B$
N = INT(N / 2)
LOOP WHILE N > 0
BIN$ = B$
END FUNCTION
fmt$ = "#### -> &"
PRINT USING fmt$; 5; BIN$(5)
PRINT USING fmt$; 50; BIN$(50)
PRINT USING fmt$; 9000; BIN$(9000)</syntaxhighlight>
==={{header|Tiny BASIC}}===
This turns into a horrible mess because of the lack of string concatenation in print statements, and the necessity of suppressing leading zeroes.
<syntaxhighlight lang="tinybasic}}">REM variables:
REM A-O: binary digits with A least significant and N most significant
REM X: number whose binary expansion we want
REM Z: running value
INPUT X
LET Z = X
IF Z = 0 THEN GOTO 999
IF (Z/2)*2<>Z THEN LET A = 1
LET Z = (Z - A) / 2
IF (Z/2)*2<>Z THEN LET B = 1
LET Z = (Z - B) / 2
IF (Z/2)*2<>Z THEN LET C = 1
LET Z = (Z - C) / 2
IF (Z/2)*2<>Z THEN LET D = 1
LET Z = (Z - D) / 2
IF (Z/2)*2<>Z THEN LET E = 1
LET Z = (Z - E) / 2
IF (Z/2)*2<>Z THEN LET F = 1
LET Z = (Z - F) / 2
IF (Z/2)*2<>Z THEN LET G = 1
LET Z = (Z - G) / 2
IF (Z/2)*2<>Z THEN LET H = 1 REM THIS IS ALL VERY TEDIOUS
LET Z = (Z - H) / 2
IF (Z/2)*2<>Z THEN LET I = 1
LET Z = (Z - I) / 2
IF (Z/2)*2<>Z THEN LET J = 1
LET Z = (Z - J) / 2
IF (Z/2)*2<>Z THEN LET K = 1
LET Z = (Z - K) / 2
IF (Z/2)*2<>Z THEN LET L = 1
LET Z = (Z - L) / 2
IF (Z/2)*2<>Z THEN LET M = 1
LET Z = (Z - M) / 2
IF (Z/2)*2<>Z THEN LET N = 1
LET Z = (Z - N) / 2
LET O = Z
IF X >= 16384 THEN GOTO 114
IF X >= 8192 THEN GOTO 113
IF X >= 4096 THEN GOTO 112
IF X >= 2048 THEN GOTO 111
IF X >= 1024 THEN GOTO 110
IF X >= 512 THEN GOTO 109
IF X >= 256 THEN GOTO 108
IF X >= 128 THEN GOTO 107 REM THIS IS ALSO TEDIOUS
IF X >= 64 THEN GOTO 106
IF X >= 32 THEN GOTO 105
IF X >= 16 THEN GOTO 104
IF X >= 8 THEN GOTO 103
IF X >= 4 THEN GOTO 102
IF X >= 2 THEN GOTO 101
PRINT 1
END
101 PRINT B,A
END
102 PRINT C,B,A
END
103 PRINT D,C,B,A
END
104 PRINT E,D,C,B,A
END
105 PRINT F,E,D,C,B,A
END
106 PRINT G,F,E,D,C,B,A
END
107 PRINT H,G,F,E,D,C,B,A
END
108 PRINT I,H,G,D,E,D,C,B,A
END
109 PRINT J,I,H,G,F,E,D,C,B,A
END
110 PRINT K,J,I,H,G,F,E,D,C,B,A
END
111 PRINT L,K,J,I,H,G,D,E,D,C,B,A
END
112 PRINT M,L,K,J,I,H,G,F,E,D,C,B,A
END
113 PRINT N,M,L,K,J,I,H,G,F,E,D,C,B,A
END
114 PRINT O,N,M,L,K,J,I,H,G,F,E,D,C,B,A
END
999 PRINT 0 REM zero is the one time we DO want to print a leading zero
END</syntaxhighlight>
==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">FUNCTION BIN$ (N)
LET N = ABS(INT(N))
LET B$ = ""
DO
LET I = MOD(N, 2)
LET B$ = STR$(I) & B$
LET N = INT(N / 2)
LOOP WHILE N > 0
LET BIN$ = B$
END FUNCTION
PRINT USING "####": 5;
PRINT " -> "; BIN$(5)
PRINT USING "####": 50;
PRINT " -> "; BIN$(50)
PRINT USING "####": 9000;
PRINT " -> "; BIN$(9000)
END</syntaxhighlight>
==={{header|XBasic}}===
{{works with|Windows XBasic}}
<syntaxhighlight lang="qbasic">PROGRAM "binardig"
VERSION "0.0000"
DECLARE FUNCTION Entry ()
FUNCTION Entry ()
DIM a[3]
a[0] = 5
a[1] = 50
a[2] = 9000
FOR i = 0 TO 2
PRINT FORMAT$ ("####", a[i]); " -> "; BIN$(a[i])
NEXT i
END FUNCTION
END PROGRAM</syntaxhighlight>
=={{header|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.
<syntaxhighlight 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</syntaxhighlight>
=={{header|bc}}==
{{trans|dc}}
<
5
50
9000
quit</
=={{header|BCPL}}==
<syntaxhighlight lang="bcpl">get "libhdr"
let writebin(x) be
$( let f(x) be
$( if x>1 then f(x>>1)
wrch((x & 1) + '0')
$)
f(x)
wrch('*N')
$)
let start() be
$( writebin(5)
writebin(50)
writebin(9000)
$)</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|Beads}}==
<syntaxhighlight lang="beads">beads 1 program 'Binary Digits'
calc main_init
loop across:[5, 50, 9000] val:v
log to_str(v, base:2)</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000
</pre>
=={{header|Befunge}}==
Reads the number to convert from standard input.
<
{{out}}
<pre>9000
10001100101000</pre>
=={{header|BQN}}==
A BQNcrate idiom which returns the digits as a boolean array.
<syntaxhighlight lang="bqn">Bin ← 2{⌽𝕗|⌊∘÷⟜𝕗⍟(↕1+·⌊𝕗⋆⁼1⌈⊢)}
Bin¨5‿50‿9000</syntaxhighlight><syntaxhighlight lang="text">⟨ ⟨ 1 0 1 ⟩ ⟨ 1 1 0 0 1 0 ⟩ ⟨ 1 0 0 0 1 1 0 0 1 0 1 0 0 0 ⟩ ⟩</syntaxhighlight>
=={{header|Bracmat}}==
<
= bit bits
. :?bits
Line 597 ⟶ 1,512:
& put$(str$(!dec ":\n" dec2bin$!dec \n\n))
)
;</
{{out}}
<pre>0:
0
Line 613 ⟶ 1,528:
423785674235000123456789:
1011001101111010111011110101001101111000000000000110001100000100111110100010101</pre>
=={{header|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.
<
[>>++<< Set up {n 0 2} for divmod magic
[->+>- Then
Line 634 ⟶ 1,548:
<[[-]<] Zero the tape for the next iteration
++++++++++. Print a newline
[-]<+] Zero it then increment n and go again</
=={{header|Burlesque}}==
<
blsq ) {5 50 9000}{2B!}m[uN
101
110010
10001100101000
</syntaxhighlight>
=={{header|C}}==
===With bit level operations===
<syntaxhighlight lang="c">#define _CRT_SECURE_NO_WARNINGS // turn off panic warnings
#define _CRT_NONSTDC_NO_DEPRECATE // enable old-gold POSIX names in MSVS
#include <stdio.h>
#include <stdlib.h>
char* bin2str(unsigned value, char* buffer)
{
// This algorithm is not the fastest one, but is relativelly simple.
//
// A faster algorithm would be conversion octets to strings by a lookup table.
// There is only 2**8 == 256 octets, therefore we would need only 2048 bytes
// for the lookup table. Conversion of a 64-bit integers would need 8 lookups
// instead 64 and/or/shifts of bits etc. Even more... lookups may be implemented
// with XLAT or similar CPU instruction... and AVX/SSE gives chance for SIMD.
const unsigned N_DIGITS = sizeof(unsigned) * 8;
unsigned mask = 1 << (N_DIGITS - 1);
char* ptr = buffer;
for (int i = 0; i < N_DIGITS; i++)
{
*ptr++ = '0' + !!(value & mask);
mask >>= 1;
}
*ptr = '\0';
// Remove leading zeros.
//
for (ptr = buffer; *ptr == '0'; ptr++)
;
return ptr;
}
char* bin2strNaive(unsigned value, char* buffer)
{
// This variation of the solution doesn't use bits shifting etc.
unsigned n, m, p;
n = 0;
p = 1; // p = 2 ** n
while (p <= value / 2)
{
n = n + 1;
p = p * 2;
}
m = 0;
while (n > 0)
{
buffer[m] = '0' + value / p;
value = value % p;
m = m + 1;
n = n - 1;
p = p / 2;
}
buffer[m + 1] = '\0';
return buffer;
}
int main(int argc, char* argv[])
{
const unsigned NUMBERS[] = { 5, 50, 9000 };
const int RADIX = 2;
char buffer[(sizeof(unsigned)*8 + 1)];
// Function itoa is an POSIX function, but it is not in C standard library.
// There is no big surprise that Microsoft deprecate itoa because POSIX is
// "Portable Operating System Interface for UNIX". Thus it is not a good
// idea to use _itoa instead itoa: we lost compatibility with POSIX;
// we gain nothing in MS Windows (itoa-without-underscore is not better
// than _itoa-with-underscore). The same holds for kbhit() and _kbhit() etc.
//
for (int i = 0; i < sizeof(NUMBERS) / sizeof(unsigned); i++)
{
unsigned value = NUMBERS[i];
itoa(value, buffer, RADIX);
printf("itoa: %u decimal = %s binary\n", value, buffer);
}
// Yeep, we can use a homemade bin2str function. Notice that C is very very
// efficient (as "hi level assembler") when bit manipulation is needed.
//
for (int i = 0; i < sizeof(NUMBERS) / sizeof(unsigned); i++)
{
unsigned value = NUMBERS[i];
printf("bin2str: %u decimal = %s binary\n", value, bin2str(value, buffer));
}
// Another implementation - see above.
//
for (int i = 0; i < sizeof(NUMBERS) / sizeof(unsigned); i++)
{
unsigned value = NUMBERS[i];
printf("bin2strNaive: %u decimal = %s binary\n", value, bin2strNaive(value, buffer));
}
return EXIT_SUCCESS;
}
</syntaxhighlight>
{{output}}
<pre>itoa: 5 decimal = 101 binary
itoa: 50 decimal = 110010 binary
itoa: 9000 decimal = 10001100101000 binary
bin2str: 5 decimal = 101 binary
bin2str: 50 decimal = 110010 binary
bin2str: 9000 decimal = 10001100101000 binary
bin2strNaive: 5 decimal = 101 binary
bin2strNaive: 50 decimal = 110010 binary
bin2strNaive: 9000 decimal = 10001100101000 binary</pre>
===With malloc and log10===
Converts int to a string.
<
#include <stdio.h>
#include <stdlib.h>
Line 672 ⟶ 1,704:
ret[bits] = '\0';
return ret;
}</
{{out}}
Line 695 ⟶ 1,727:
10010
10011</pre>
=={{header|C sharp|C#}}==
<syntaxhighlight lang="csharp">using System;
class Program
{
static void Main()
{
foreach (var number in new[] { 5, 50, 9000 })
{
Console.WriteLine(Convert.ToString(number, 2));
}
}
}</syntaxhighlight>
Another version using dotnet 5<syntaxhighlight lang="csharp dotnet 5.0">using System;
using System.Text;
static string ToBinary(uint x) {
if(x == 0) return "0";
var bin = new StringBuilder();
for(uint mask = (uint)1 << (sizeof(uint)*8 - 1);mask > 0;mask = mask >> 1)
bin.Append((mask & x) > 0 ? "1" : "0");
return bin.ToString().TrimStart('0');
}
Console.WriteLine(ToBinary(5));
Console.WriteLine(ToBinary(50));
Console.WriteLine(ToBinary(9000));</syntaxhighlight>
{{out}}
<pre>
101
110010
10001100101000
</pre>
=={{header|C++}}==
<
#include <iostream>
#include <limits>
Line 719 ⟶ 1,783:
print_bin(9000);
}
</syntaxhighlight>
{{out}}
<pre>
0
Line 728 ⟶ 1,792:
</pre>
Shorter version using bitset
<
#include <bitset>
void printBits(int n) { // Use int like most programming languages.
Line 741 ⟶ 1,805:
printBits(50);
printBits(9000);
} // for testing with n=0 printBits<32>(0);</
Using >> operator. (1st example is 2.75x longer. Matter of taste.)
<
int main(int argc, char* argv[]) {
unsigned int in[] = {5, 50, 9000}; // Use int like most programming languages
Line 751 ⟶ 1,815:
std::cout << ('0' + b & 1) << (!at ? "\n": ""); // '0' or '1'. Add EOL if last bit of num
}
</syntaxhighlight>
To be fair comparison with languages that doesn't declare a function like C++ main(). 3.14x shorter than 1st example.
<
int main(int argc, char* argv[]) { // Usage: program.exe 5 50 9000
for (int i = 1; i < argc; i++) // argv[0] is program name
Line 760 ⟶ 1,824:
std::cout << ('0' + b & 1) << (!at ? "\n": ""); // '0' or '1'. Add EOL if last bit of num
}
</syntaxhighlight>
Using bitwise operations with recursion.
<
#include <iostream>
Line 774 ⟶ 1,838:
}
}
</syntaxhighlight>
{{out}}
<pre>
101
Line 781 ⟶ 1,845:
10001100101000
</pre>
=={{header|Ceylon}}==
<syntaxhighlight lang="ceylon"> shared void run() {
void printBinary(Integer integer) =>
print(Integer.format(integer, 2));
printBinary(5);
printBinary(50);
printBinary(9k);
}</syntaxhighlight>
=={{header|Clojure}}==
<
(Integer/toBinaryString 50)
(Integer/toBinaryString 9000)</
=={{header|CLU}}==
<syntaxhighlight lang="clu">binary = proc (n: int) returns (string)
bin: string := ""
while n > 0 do
bin := string$c2s(char$i2c(48 + n // 2)) || bin
n := n / 2
end
return(bin)
end binary
start_up = proc ()
po: stream := stream$primary_output()
tests: array[int] := array[int]$[5, 50, 9000]
for test: int in array[int]$elements(tests) do
stream$putl(po, int$unparse(test) || " -> " || binary(test))
end
end start_up</syntaxhighlight>
{{out}}
<pre>5 -> 101
50 -> 110010
9000 -> 10001100101000</pre>
=={{header|COBOL}}==
<
PROGRAM-ID. SAMPLE.
Line 814 ⟶ 1,908:
display binary_number
stop run.
</syntaxhighlight>
Free-form, using a reference modifier to index into binary-number.
<
PROGRAM-ID. binary-conversion.
Line 842 ⟶ 1,936:
end-perform.
display binary-number.
stop run.</
=={{header|CoffeeScript}}==
<
new Number(n).toString(2)
console.log binary n for n in [5, 50, 9000]</
=={{header|Common Lisp}}==
Just print the number with "~b":
<
; or
(write 5 :base 2)</
=={{header|Component Pascal}}==
BlackBox Component Builder
<
MODULE BinaryDigits;
IMPORT StdLog,Strings;
Line 896 ⟶ 1,967:
END Do;
END BinaryDigits.
</syntaxhighlight>
Execute: ^Q BinaryDigits.Do <br/>
{{out}}
<pre>
5:> 101
50:> 110010
9000:> 10001100101000</pre>
=={{header|Cowgol}}==
<syntaxhighlight lang="cowgol">include "cowgol.coh";
sub print_binary(n: uint32) is
var buffer: uint8[33];
var p := &buffer[32];
[p] := 0;
while n != 0 loop
p := @prev p;
[p] := ((n as uint8) & 1) + '0';
n := n >> 1;
end loop;
print(p);
print_nl();
end sub;
print_binary(5);
print_binary(50);
print_binary(9000);</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|Crystal}}==
{{trans|Ruby}}
Using an array
<syntaxhighlight lang="ruby">[5,50,9000].each do |n|
puts "%b" % n
end</syntaxhighlight>
Using a tuple
<syntaxhighlight lang="ruby">{5,50,9000}.each { |n| puts n.to_s(2) }</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|D}}==
<
import std.stdio;
foreach (immutable i; 0 .. 16)
writefln("%b", i);
}</
{{out}}
<pre>0
Line 928 ⟶ 2,035:
1110
1111</pre>
=={{header|Dart}}==
<
if(n<0)
throw new IllegalArgumentException("negative numbers require 2s complement");
Line 954 ⟶ 2,060:
// fails due to precision limit
print(binary(0x123456789abcdef));
}</
=={{header|dc}}==
<syntaxhighlight lang
{{out}}
Line 963 ⟶ 2,068:
110010
10001100101000</pre>
=={{header|Delphi}}==
<syntaxhighlight lang="delphi">
program BinaryDigit;
{$APPTYPE CONSOLE}
Line 984 ⟶ 2,088:
writeln(' 50: ',IntToBinStr(50));
writeln('9000: '+IntToBinStr(9000));
end.</
{{out}}
<pre>
5: 101
50: 110010
9000: 10001100101000
</pre>
=={{header|Draco}}==
<syntaxhighlight lang="draco">proc main() void:
writeln(5:b);
writeln(50:b);
writeln(9000:b);
corp</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|dt}}==
<syntaxhighlight lang="dt">[dup 1 gt? [dup 2 % swap 2 / loop] swap do?] \loop def
[\loop doin rev \to-string map "" join] \bin def
[0 1 2 5 50 9000] \bin map " " join pl</syntaxhighlight>
{{out}}
<pre>0 1 10 101 110010 10001100101000</pre>
=={{header|Dyalect}}==
A default <code>ToString</code> method of type <code>Integer</code> is overridden and returns a binary representation of a number:
<syntaxhighlight lang="dyalect">func Integer.ToString() {
var s = ""
for x in 31^-1..0 {
if this &&& (1 <<< x) != 0 {
s += "1"
} else if s != "" {
s += "0"
}
}
s
}
print("5 == \(5), 50 = \(50), 1000 = \(9000)")</syntaxhighlight>
{{out}}
<pre>5 == 101, 50 = 110010, 1000 = 10001100101000</pre>
=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
func$ bin num .
b$ = ""
while num > 1
b$ = num mod 2 & b$
num = num div 2
.
return num & b$
.
print bin 5
print bin 50
print bin 9000
</syntaxhighlight>
{{out}}
<pre>
101
110010
10001100101000
</pre>
=={{header|EchoLisp}}==
<
;; primitive : (number->string number [base]) - default base = 10
Line 1,003 ⟶ 2,168:
110010
10001100101000
</syntaxhighlight>
=={{header|Ecstasy}}==
<syntaxhighlight lang="java">
module BinaryDigits {
@Inject Console console;
void run() {
Int64[] tests = [0, 1, 5, 50, 9000];
Int longestInt = tests.map(n -> n.estimateStringLength())
.reduce(0, (max, len) -> max.notLessThan(len));
Int longestBin = tests.map(n -> (64-n.leadingZeroCount).notLessThan(1))
.reduce(0, (max, len) -> max.maxOf(len));
function String(Int64) num = n -> {
Int indent = longestInt - n.estimateStringLength();
return $"{' ' * indent}{n}";
};
function String(Int64) bin = n -> {
Int index = n.leadingZeroCount.minOf(63);
Int indent = index - (64 - longestBin);
val bits = n.toBitArray()[index ..< 64];
return $"{' ' * indent}{bits.toString().substring(2)}";
};
for (Int64 test : tests) {
console.print($"The decimal value {num(test)} should produce an output of {bin(test)}");
}
}
}
</syntaxhighlight>
{{out}}
<pre>
The decimal value 0 should produce an output of 0
The decimal value 1 should produce an output of 1
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
</pre>
=={{header|Elena}}==
ELENA
<
public program()
{
console
}</syntaxhighlight>
{{out}}
<pre>
Line 1,029 ⟶ 2,231:
=={{header|Elixir}}==
Use <code>Integer.to_string</code> with a base of 2:
<syntaxhighlight lang="elixir">
IO.puts Integer.to_string(5, 2)
</syntaxhighlight>
Or, using the pipe operator:
<syntaxhighlight lang="elixir">
5 |> Integer.to_string(2) |> IO.puts
</syntaxhighlight>
<syntaxhighlight lang="elixir">
[5,50,9000] |> Enum.each(fn n -> IO.puts Integer.to_string(n, 2) end)
</syntaxhighlight>
{{out}}
Line 1,046 ⟶ 2,248:
10001100101000
</pre>
With Enum.map/2
<syntaxhighlight lang="elixir">
Enum.map([5, 50, 9000], fn n -> IO.puts Integer.to_string(n, 2) end)
</syntaxhighlight>
{{out}}
<pre>
101
110010
10001100101000
</pre>
With list comprehension
<syntaxhighlight lang="elixir">
for n <- [5, 50, 9000] do IO.puts Integer.to_string(n, 2) end
</syntaxhighlight>
{{out}}
<pre>
101
110010
10001100101000
</pre>
=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">
(defun int-to-binary (val)
(let ((x val) (result ""))
(while (> x 0)
(setq result (concat (number-to-string (% x 2)) result))
(setq x (/ x 2)))
result))
(message "5 => %s" (int-to-binary 5))
(message "50 => %s" (int-to-binary 50))
(message "9000 => %s" (int-to-binary 9000))
</syntaxhighlight>
{{out}}
<pre>
5 => 101
50 => 110010
9000 => 10001100101000
</pre>
=={{header|Epoxy}}==
<syntaxhighlight lang="epoxy">fn bin(a,b:true)
var c:""
while a>0 do
c,a:tostring(a%2)+c,bit.rshift(a,1)
cls
if b then
c:string.repeat("0",16-#c)+c
cls
return c
cls
var List: [5,50,9000]
iter Value of List do
log(Value+": "+bin(Value,false))
cls</syntaxhighlight>
{{out}}
<pre>
5: 101
50: 110010
9000: 10001100101000
</pre>
=={{header|Erlang}}==
With lists:map/2
<syntaxhighlight lang="erlang">lists:map( fun(N) -> io:fwrite("~.2B~n", [N]) end, [5, 50, 9000]).</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
With list comprehension
<syntaxhighlight lang="erlang">[io:fwrite("~.2B~n", [N]) || N <- [5, 50, 9000]].</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
With list comprehension and integer_to_list/2
<syntaxhighlight lang="erlang">[io:fwrite("~s~n", [integer_to_list(N, 2)]) || N <- [5, 50, 9000]].</syntaxhighlight>
{{out}}
<pre>101
110010
Line 1,055 ⟶ 2,335:
=={{header|Euphoria}}==
<
sequence s
s = {}
Line 1,067 ⟶ 2,347:
puts(1, toBinary(5) & '\n')
puts(1, toBinary(50) & '\n')
puts(1, toBinary(9000) & '\n')</
=== Functional/Recursive ===
<
include std/convert.e
Line 1,085 ⟶ 2,365:
printf(1, "%d\n", Bin(5))
printf(1, "%d\n", Bin(50))
printf(1, "%d\n", Bin(9000))</
=={{header|F Sharp|F#}}==
<
for i in [5; 50; 9000] do printfn "%s" <| Convert.ToString (i, 2)</
<
// define the function
Line 1,102 ⟶ 2,381:
// use the function
[5; 50; 9000]
|> List.iter printBin</
Or more idiomatic so that you can use it with any printf-style function and the <code>%a</code> format specifier (most flexible):
<syntaxhighlight lang="fsharp">open System
open System.IO
// define a callback function for %a
let bin (tw: TextWriter) value =
tw.Write("{0}", Convert.ToString(int64 value, 2))
// use it with printfn with %a
[5; 50; 9000]
|> List.iter (printfn "binary: %a" bin)</syntaxhighlight>
Output (either version):
<pre>
Line 1,109 ⟶ 2,401:
10001100101000
</pre>
=={{header|Factor}}==
<
5 >bin print
50 >bin print
9000 >bin print</
=={{header|FALSE}}==
<syntaxhighlight lang="false">[0\10\[$1&'0+\2/$][]#%[$][,]#%]b:
5 b;!
50 b;!
9000 b;!</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|FBSL}}==
<
function Bin(byval n as integer, byval s as string = "") as string
if n > 0 then return Bin(n \ 2, (n mod 2) & s)
Line 1,130 ⟶ 2,430:
pause
</syntaxhighlight>
=={{header|FOCAL}}==
<syntaxhighlight lang="focal">01.10 S A=5;D 2
01.20 S A=50;D 2
01.30 S A=9000;D 2
01.40 Q
02.10 S BX=0
02.20 S BD(BX)=A-FITR(A/2)*2
02.25 S A=FITR(A/2)
02.30 S BX=BX+1
02.35 I (-A)2.2
02.40 S BX=BX-1
02.45 D 2.6
02.50 I (-BX)2.4;T !;R
02.60 I (-BD(BX))2.7;T "0";R
02.70 T "1"</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|Forth}}==
<
\ HEX is a standard word to change the value of base to 16
Line 1,140 ⟶ 2,459:
\ we can easily compile a word into the system to set 'BASE' to 2
: binary 2 base ! ;
\ interactive console test with conversion and binary masking example
hex 0FF binary .
decimal 679 binary .
binary 11111111111 00000110000 and . cr
decimal
</syntaxhighlight>
{{out}}
<pre>
11111111
1010100111
110000
</pre>
=={{header|Fortran}}==
Please find compilation instructions and the example run at the start of the FORTRAN90 source that follows. Thank you.
<syntaxhighlight lang="fortran">
!-*- mode: compilation; default-directory: "/tmp/" -*-
!Compilation started at Sun May 19 23:14:14
Line 1,214 ⟶ 2,540:
end program bits
</syntaxhighlight>
=={{header|Free Pascal}}==
As part of the RTL (run-time library) that is shipped with every FPC (Free Pascal compiler) distribution, the <tt>system</tt> unit contains the function <tt>binStr</tt>.
The <tt>system</tt> unit is automatically included by ''every'' program and is guaranteed to work on every supported platform.
<syntaxhighlight lang="pascal">program binaryDigits(input, output, stdErr);
{$mode ISO}
function binaryNumber(const value: nativeUInt): shortString;
const
one = '1';
var
representation: shortString;
begin
representation := binStr(value, bitSizeOf(value));
// strip leading zeroes, if any; NB: mod has to be ISO compliant
delete(representation, 1, (pos(one, representation)-1) mod bitSizeOf(value));
// traditional Pascal fashion:
// assign result to the (implicitely existent) variable
// that is named like the function’s name
binaryNumber := representation;
end;
begin
writeLn(binaryNumber(5));
writeLn(binaryNumber(50));
writeLn(binaryNumber(9000));
end.</syntaxhighlight>
Note, that the ISO compliant <tt>mod</tt> operation has to be used, which is ensured by the <tt>{$mode}</tt> directive in the second line.
=={{header|FreeBASIC}}==
<
' FreeBASIC v1.05.0 win64
Dim As String fmt = "#### -> &"
Line 1,227 ⟶ 2,579:
Sleep
End
</syntaxhighlight>
{{out}}
Line 1,235 ⟶ 2,587:
9000 -> 10001100101000
</pre>
=={{header|Frink}}==
The following all provide equivalent output. Input can be arbitrarily-large integers.
<syntaxhighlight lang="frink">
9000 -> binary
9000 -> base2
base2[9000]
base[9000, 2]
</syntaxhighlight>
=={{header|FunL}}==
<
println( n, bin(n) )</
{{out}}
Line 1,248 ⟶ 2,607:
9000000000, 1000011000011100010001101000000000
</pre>
=={{header|Futhark}}==
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.
<syntaxhighlight lang="futhark">
fun main(x: i32): i64 =
loop (out = 0i64) = for i < 32 do
Line 1,260 ⟶ 2,618:
in out
in out
</syntaxhighlight>
=={{header|FutureBasic}}==
The decimal to binary conversion can be handled with a simple function.
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"
local fn IntegerToBinaryStr( x as NSInteger ) as CFStringRef
CFStringRef resultStr : resultStr = @""
while ( x )
resultStr = fn StringByAppendingString( fn StringWithFormat( @"%lu", x && 1 ), resultStr )
x = x >> 1
wend
end fn = resultStr
NSLog( @" 5 = %@", fn IntegerToBinaryStr( 5 ) )
NSLog( @" 50 = %@", fn IntegerToBinaryStr( 50 ) )
NSLog( @"9000 = %@", fn IntegerToBinaryStr( 9000 ) )
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
5 = 101
50 = 110010
9000 = 10001100101000
</pre>
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=03e84768e6ee2af9b7664efa04fa6da8 Click this link to run this code]'''
<syntaxhighlight lang="gambas">Public Sub Main()
Dim siBin As Short[] = [5, 50, 9000]
Dim siCount As Short
Line 1,280 ⟶ 2,655:
Next
End</
{{out}}
<pre>
101
Line 1,287 ⟶ 2,662:
10001100101000
</pre>
=={{header|Go}}==
<
import (
Line 1,299 ⟶ 2,673:
fmt.Printf("%b\n", i)
}
}</
{{out}}
<pre>
Line 1,319 ⟶ 2,693:
1111
</pre>
=={{header|Groovy}}==
Solutions:
<
n binary
----- ---------------
Line 1,328 ⟶ 2,701:
[5, 50, 9000].each {
printf('%5d %15s\n', it, Integer.toBinaryString(it))
}</
{{out}}
<pre> n binary
----- ---------------
Line 1,335 ⟶ 2,708:
50 110010
9000 10001100101000</pre>
=={{header|Haskell}}==
<
import Numeric
import Text.Printf
-- Use the built-in function showBin.
toBin n = showBin n ""
-- Use the built-in function showIntAtBase.
Line 1,360 ⟶ 2,735:
main = do
putStrLn $ printf "%4s %14s %14s" "N" "toBin" "toBin1"
mapM_ printToBin [5, 50, 9000]</
{{out}}
<pre>
N toBin toBin1
5 101 101
Line 1,367 ⟶ 2,743:
9000 10001100101000 10001100101000
</pre>
and in terms of first and swap, we could also write this as:
<syntaxhighlight lang="haskell">import Data.Bifunctor (first)
import Data.List (unfoldr)
import Data.Tuple (swap)
---------------------- BINARY DIGITS ---------------------
binaryDigits :: Int -> String
binaryDigits = reverse . unfoldr go
where
go 0 = Nothing
go n = Just . first ("01" !!) . swap . quotRem n $ 2
--------------------------- TEST -------------------------
main :: IO ()
main =
mapM_
( putStrLn
. ( ((<>) . (<> " -> ") . show)
<*> binaryDigits
)
)
[5, 50, 9000]</syntaxhighlight>
{{Out}}
<pre>5 -> 101
50 -> 110010
9000 -> 10001100101000</pre>
=={{header|Icon}} and {{header|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.
<
every i := 5 | 50 | 255 | 1285 | 9000 do
write(i," = ",binary(i))
Line 1,392 ⟶ 2,799:
}
return reverse(trim(b,"0")) # nothing extraneous
end</
{{out}}
<pre>5 = 101
50 = 110010
Line 1,399 ⟶ 2,806:
1285 = 10100000101
9000 = 10001100101000</pre>
=={{header|Idris}}==
<
binaryDigit : Integer -> Char
Line 1,420 ⟶ 2,825:
putStrLn (binaryString 50)
putStrLn (binaryString 9000)
</syntaxhighlight>
{{out}}
<pre>
0
Line 1,430 ⟶ 2,833:
10001100101000
</pre>
=={{header|J}}==
Generate a list of binary digits and use it to select characters from string '01'.
<syntaxhighlight lang="j"> tobin=: '01'{~#:
tobin 5
101
Line 1,438 ⟶ 2,841:
110010
tobin 9000
10001100101000</
Uses implicit output.
=={{header|Java}}==
<p>
The <code>Integer</code> class offers the <code>toBinaryString</code> method.
</p>
<syntaxhighlight lang="java">
</syntaxhighlight>
<syntaxhighlight lang="java">
Integer.toBinaryString(50);
</syntaxhighlight>
<syntaxhighlight lang="java">
Integer.toBinaryString(9000);
</syntaxhighlight>
<p>
If you printed these values you would get the following.
</p>
<pre>
101
110010
10001100101000
</pre>
=={{header|JavaScript}}==
===ES5===
<syntaxhighlight 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]));
}</syntaxhighlight>
===ES6===
The simplest showBinary (or showIntAtBase), using default digit characters, would use JavaScript's standard String.toString(base):
<syntaxhighlight lang="javascript">(() => {
"use strict";
// ------------------ BINARY DIGITS ------------------
// showBinary :: Int -> String
const showBinary = n =>
showIntAtBase_(2)(n);
// showIntAtBase_ :: // Int -> Int -> String
const showIntAtBase_ = base =>
n => n.toString(base);
// ---------------------- TEST -----------------------
const main = () => [5, 50, 9000]
.map(n => `${n} -> ${showBinary(n)}`)
.join("\n");
// MAIN ---
return main();
})();</syntaxhighlight>
{{Out}}
<pre>5 -> 101
50 -> 110010
9000 -> 10001100101000</pre>
Or, if we need more flexibility with the set of digits used, we can write a version of showIntAtBase which takes a more specific Int -> Char function as as an argument. This one is a rough translation of Haskell's Numeric.showIntAtBase:
<syntaxhighlight lang="javascript">(() => {
"use strict";
// -------------- DIGITS FOR GIVEN BASE --------------
// showIntAtBase :: Int -> (Int -> Char) ->
// Int -> String -> String
const showIntAtBase = base =>
// A string representation of n, in the given base,
// using a supplied (Int -> Char) function for digits,
// and a supplied suffix string.
toChr => n => rs => {
const go = ([x, d], r) => {
const r_ = toChr(d) + r;
return 0 !== x ? (
go(quotRem(x)(base), r_)
) : r_;
};
const e = "error: showIntAtBase applied to";
return 1 >= base ? (
`${e} unsupported base`
) : 0 > n ? (
`${e} negative number`
) : go(quotRem(n)(base), rs);
};
// ---------------------- TEST -----------------------
const main = () => {
// showHanBinary :: Int -> String
const showHanBinary = n =>
showIntAtBase(2)(
x => "〇一" [x]
)(n)("");
return [5, 50, 9000]
.map(
n => `${n} -> ${showHanBinary(n)}`
)
.join("\n");
};
// --------------------- GENERIC ---------------------
// quotRem :: Integral a => a -> a -> (a, a)
const quotRem = m =>
// The quotient, tupled with the remainder.
n => [Math.trunc(m / n), m % n];
// MAIN ---
return main();
})();</syntaxhighlight>
{{Out}}
<pre>5 -> 一〇一
50 -> 一一〇〇一〇
9000 -> 一〇〇〇一一〇〇一〇一〇〇〇</pre>
=={{header|Joy}}==
<syntaxhighlight lang="joy">DEFINE bin == "" [pop 1 >] [[2 div "01" of] dip cons] while ["01" of] dip cons.
[0 1 2 5 50 9000] [bin] map put.</syntaxhighlight>
{{out}}
<pre>["0" "1" "10" "101" "110010" "10001100101000"]</pre>
=={{header|jq}}==
<
[ recurse( ./2 | floor; . > 0) % 2 ] | reverse | join("") ;
# The task:
(5, 50, 9000) | binary_digits</
{{Out}}
$ jq -n -r -f Binary_digits.jq
Line 1,508 ⟶ 2,990:
110010
10001100101000
=={{header|Julia}}==
<syntaxhighlight lang="julia">using Printf
for n in (0, 5, 50, 9000)
@printf("%6i → %s\n", n, string(n, base=2))
end
# with pad
println("\nwith pad")
for n in (0, 5, 50, 9000)
@printf("%6i → %s\n", n, string(n, base=2, pad=20))
end</syntaxhighlight>
{{out}}
<pre> 0 → 0
5 → 101
50 → 110010
9000 → 10001100101000
with pad
0 → 00000000000000000000
5 → 00000000000000000101
50 → 00000000000000110010
9000 → 00000010001100101000</pre>
=={{header|K}}==
<
tobin' 5 50 9000
("101"
"110010"
"10001100101000")</
=={{header|Kotlin}}==
<syntaxhighlight lang="kotlin">
fun main() {
val numbers = intArrayOf(5, 50, 9000)
numbers.forEach { println("$it -> ${it.toString(2)}") }
}</
{{out}}
<pre>
9000 -> 10001100101000
</pre>
=={{header|Ksh}}==
<syntaxhighlight lang="ksh">function bin {
typeset -i2 n=$1
print -r -- "${n#2#}"
}
print -r -- $(for i in 0 1 2 5 50 9000; do bin "$i"; done)</syntaxhighlight>
{{out}}
<pre>0 1 10 101 110010 10001100101000</pre>
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{def dec2bin
{lambda {:dec}
{if {= :dec 0}
then 0
else {if {< :dec 2}
then 1
else {dec2bin {floor {/ :dec 2}}}{% :dec 2} }}}}
-> dec2bin
{dec2bin 5} -> 101
{dec2bin 5} -> 110010
{dec2bin 9000} -> 10001100101000
{S.map dec2bin 5 50 9000}
-> 101 110010 10001100101000
{S.map {lambda {:i} {br}:i -> {dec2bin :i}} 5 50 9000}
->
5 -> 101
50 -> 110010
9000 -> 10001100101000
</syntaxhighlight>
As a (faster) alternative we can ask some help from Javascript who knows how to do:
<syntaxhighlight lang="scheme">
1) we add to the lambdatalk's dictionary the Javascript primitive "dec2bin"
{script
LAMBDATALK.DICT["dec2bin"] = function() {
return Number( arguments[0].trim() ).toString(2)
};
}
2) we use it in the wiki page:
'{S.map dec2bin 5 50 9000}
-> 101 110010 10001100101000
}
</syntaxhighlight>
=={{header|Lang}}==
<syntaxhighlight lang="lang">
fn.println(fn.toTextBase(5, 2))
fn.println(fn.toTextBase(50, 2))
fn.println(fn.toTextBase(9000, 2))
</syntaxhighlight>
=={{header|Lang5}}==
<
[5 50 9000] [3 1] reshape .</
{{out}}
<pre>[
Line 1,555 ⟶ 3,103:
[ 10001100101000 ]
]</pre>
=={{header|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:
<
(: io format '"~.2B~n~.2B~n~.2B~n" (list 5 50 9000))
</syntaxhighlight>
If, however, you do need to get the results from a function, you can use <code>(: erlang integer_to_list ... )</code>. Here's a simple example that does the same thing as the previous code:
<
(: lists foreach
(lambda (x)
Line 1,571 ⟶ 3,118:
(list (: erlang integer_to_list x 2))))
(list 5 50 9000))
</syntaxhighlight>
{{out|note=for both examples}}
<pre>
101
Line 1,579 ⟶ 3,125:
10001100101000
</pre>
=={{header|Liberty BASIC}}==
<
print a;"=";dec2bin$(a)
next
Line 1,596 ⟶ 3,141:
wend
end function
</syntaxhighlight>
=={{header|Little Man Computer}}==
Runs in a home-made simulator, which is compatible with Peter Higginson's online simulator except that it has more room for output. Makes use of PH's non-standard OTC instruction to output ASCII characters.
The maximum integer in LMC is 999, so 90000 in the task is here replaced by 900.
<syntaxhighlight lang="little man computer">
// Little Man Computer, for Rosetta Code.
// Read numbers from user and display them in binary.
// Exit when input = 0.
input INP
BRZ zero
STA N
// Write number followed by '->'
OUT
LDA asc_hy
OTC
LDA asc_gt
OTC
// Find greatest power of 2 not exceeding N,
// and count how many digits will be output
LDA c1
STA pwr2
loop STA nrDigits
LDA N
SUB pwr2
SUB pwr2
BRP double
BRA part2 // jump out if next power of 2 would exceed N
double LDA pwr2
ADD pwr2
STA pwr2
LDA nrDigits
ADD c1
BRA loop
// Write the binary digits
part2 LDA N
SUB pwr2
set_diff STA diff
LDA asc_1 // first digit is always 1
wr_digit OTC // write digit
LDA nrDigits // count down the number of digits
SUB c1
BRZ input // if all digits done, loop for next number
STA nrDigits
// We now want to compare diff with pwr2/2.
// Since division is awkward in LMC, we compare 2*diff with pwr2.
LDA diff // diff := diff * 2
ADD diff
STA diff
SUB pwr2 // is diff >= pwr2 ?
BRP set_diff // yes, update diff and write '1'
LDA asc_0 // no, write '0'
BRA wr_digit
zero HLT // stop if input = 0
// Constants
c1 DAT 1
asc_hy DAT 45
asc_gt DAT 62
asc_0 DAT 48
asc_1 DAT 49
// Variables
N DAT
pwr2 DAT
nrDigits DAT
diff DAT
</syntaxhighlight>
{{out}}
<pre>
5->101
50->110010
900->1110000100
</pre>
=={{header|LLVM}}==
{{trans|C}}
<syntaxhighlight lang="llvm">; ModuleID = 'binary.c'
; source_filename = "binary.c"
; target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
; target triple = "x86_64-pc-windows-msvc19.21.27702"
; This is not strictly LLVM, as it uses the C library function "printf".
; LLVM does not provide a way to print values, so the alternative would be
; to just load the string into memory, and that would be boring.
; Additional comments have been inserted, as well as changes made from the output produced by clang such as putting more meaningful labels for the jumps
$"\01??_C@_03OFAPEBGM@?$CFs?6?$AA@" = comdat any
;--- String constant defintions
@"\01??_C@_03OFAPEBGM@?$CFs?6?$AA@" = linkonce_odr unnamed_addr constant [4 x i8] c"%s\0A\00", comdat, align 1
;--- The declaration for the external C printf function.
declare i32 @printf(i8*, ...)
;--- The declaration for the external C log10 function.
declare double @log10(double) #1
;--- The declaration for the external C malloc function.
declare noalias i8* @malloc(i64) #2
;--- The declaration for the external C free function.
declare void @free(i8*) #2
;----------------------------------------------------------
;-- Function that allocates a string with a binary representation of a number
define i8* @bin(i32) #0 {
;-- uint32_t x (local copy)
%2 = alloca i32, align 4
;-- size_t bits
%3 = alloca i64, align 8
;-- intermediate value
%4 = alloca i8*, align 8
;-- size_t i
%5 = alloca i64, align 8
store i32 %0, i32* %2, align 4
;-- x == 0, start determinig what value to initially store in bits
%6 = load i32, i32* %2, align 4
%7 = icmp eq i32 %6, 0
br i1 %7, label %just_one, label %calculate_logs
just_one:
br label %assign_bits
calculate_logs:
;-- log10((double) x)/log10(2) + 1
%8 = load i32, i32* %2, align 4
%9 = uitofp i32 %8 to double
;-- log10((double) x)
%10 = call double @log10(double %9) #3
;-- log10(2)
%11 = call double @log10(double 2.000000e+00) #3
;-- remainder of calculation
%12 = fdiv double %10, %11
%13 = fadd double %12, 1.000000e+00
br label %assign_bits
assign_bits:
;-- bits = (x == 0) ? 1 : log10((double) x)/log10(2) + 1;
;-- phi basically selects what the value to assign should be based on which basic block came before
%14 = phi double [ 1.000000e+00, %just_one ], [ %13, %calculate_logs ]
%15 = fptoui double %14 to i64
store i64 %15, i64* %3, align 8
;-- char *ret = malloc((bits + 1) * sizeof (char));
%16 = load i64, i64* %3, align 8
%17 = add i64 %16, 1
%18 = mul i64 %17, 1
%19 = call noalias i8* @malloc(i64 %18)
store i8* %19, i8** %4, align 8
store i64 0, i64* %5, align 8
br label %loop
loop:
;-- i < bits;
%20 = load i64, i64* %5, align 8
%21 = load i64, i64* %3, align 8
%22 = icmp ult i64 %20, %21
br i1 %22, label %loop_body, label %exit
loop_body:
;-- ret[bits - i - 1] = (x & 1) ? '1' : '0';
%23 = load i32, i32* %2, align 4
%24 = and i32 %23, 1
%25 = icmp ne i32 %24, 0
%26 = zext i1 %25 to i64
%27 = select i1 %25, i32 49, i32 48
%28 = trunc i32 %27 to i8
%29 = load i8*, i8** %4, align 8
%30 = load i64, i64* %3, align 8
%31 = load i64, i64* %5, align 8
%32 = sub i64 %30, %31
%33 = sub i64 %32, 1
%34 = getelementptr inbounds i8, i8* %29, i64 %33
store i8 %28, i8* %34, align 1
;-- x >>= 1;
%35 = load i32, i32* %2, align 4
%36 = lshr i32 %35, 1
store i32 %36, i32* %2, align 4
br label %loop_increment
loop_increment:
;-- i++;
%37 = load i64, i64* %5, align 8
%38 = add i64 %37, 1
store i64 %38, i64* %5, align 8
br label %loop
exit:
;-- ret[bits] = '\0';
%39 = load i8*, i8** %4, align 8
%40 = load i64, i64* %3, align 8
%41 = getelementptr inbounds i8, i8* %39, i64 %40
store i8 0, i8* %41, align 1
;-- return ret;
%42 = load i8*, i8** %4, align 8
ret i8* %42
}
;----------------------------------------------------------
;-- Entry point into the program
define i32 @main() #0 {
;-- 32-bit zero for the return
%1 = alloca i32, align 4
;-- size_t i, for tracking the loop index
%2 = alloca i64, align 8
;-- char* for the result of the bin call
%3 = alloca i8*, align 8
;-- initialize
store i32 0, i32* %1, align 4
store i64 0, i64* %2, align 8
br label %loop
loop:
;-- while (i < 20)
%4 = load i64, i64* %2, align 8
%5 = icmp ult i64 %4, 20
br i1 %5, label %loop_body, label %exit
loop_body:
;-- char *binstr = bin(i);
%6 = load i64, i64* %2, align 8
%7 = trunc i64 %6 to i32
%8 = call i8* @bin(i32 %7)
store i8* %8, i8** %3, align 8
;-- printf("%s\n", binstr);
%9 = load i8*, i8** %3, align 8
%10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"\01??_C@_03OFAPEBGM@?$CFs?6?$AA@", i32 0, i32 0), i8* %9)
;-- free(binstr);
%11 = load i8*, i8** %3, align 8
call void @free(i8* %11)
br label %loop_increment
loop_increment:
;-- i++
%12 = load i64, i64* %2, align 8
%13 = add i64 %12, 1
store i64 %13, i64* %2, align 8
br label %loop
exit:
;-- return 0 (implicit)
%14 = load i32, i32* %1, align 4
ret i32 %14
}
attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #2 = { "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #3 = { nounwind }
!llvm.module.flags = !{!0, !1}
!llvm.ident = !{!2}
!0 = !{i32 1, !"wchar_size", i32 2}
!1 = !{i32 7, !"PIC Level", i32 2}
!2 = !{!"clang version 6.0.1 (tags/RELEASE_601/final)"}</syntaxhighlight>
{{out}}
<pre>0
1
10
11
100
101
110
111
1000
1001
1010
1011
1100
1101
1110
1111
10000
10001
10010
10011</pre>
=={{header|Locomotive Basic}}==
<
20 PRINT BIN$(50)
30 PRINT BIN$(9000)</
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|LOLCODE}}==
<syntaxhighlight lang="lolcode">HAI 1.3
HOW IZ I DECIMULBINUR YR DECIMUL
I HAS A BINUR ITZ ""
IM IN YR DUUH
BOTH SAEM DECIMUL AN SMALLR OF DECIMUL AN 0, O RLY?
YA RLY, GTFO
OIC
BINUR R SMOOSH MOD OF DECIMUL AN 2 BINUR MKAY
DECIMUL R MAEK
IM OUTTA YR DUUH
FOUND YR BINUR
IF U SAY SO
VISIBLE I IZ DECIMULBINUR YR 5 MKAY
VISIBLE I IZ DECIMULBINUR YR 50 MKAY
VISIBLE I IZ DECIMULBINUR YR 9000 MKAY
KTHXBYE</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|Lua}}==
===Lua - Iterative===
<syntaxhighlight lang="lua">function dec2bin(n)
local bin = ""
while n >
bin = n % 2 .. bin
n = math.floor(n / 2)
end
return n .. bin
end
print(dec2bin(5))
print(dec2bin(50))
print(dec2bin(9000))</
{{out}}
<pre>101
110010
10001100101000</pre>
===Lua - Recursive===
{{works with|Lua|5.3+}}
<syntaxhighlight lang="lua">-- for Lua 5.1/5.2 use math.floor(n/2) instead of n>>1, and n%2 instead of n&1
function dec2bin(n)
return n>1 and dec2bin(n>>1)..(n&1) or n
end
print(dec2bin(5))
print(dec2bin(50))
print(dec2bin(9000))</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module Checkit {
Form 90, 40
Function BinFunc${
Dim Base 0, One$(16)
One$( 0 ) = "0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"
=lambda$ One$() (x, oct as long=4, bypass as boolean=True) ->{
if oct>0 and oct<5 then {
oct=2*(int(4-oct) mod 4+1)-1
} Else oct=1
hx$ = Hex$(x, 4 )
Def Ret$
If Bypass then {
For i= oct to len(hx$)
if bypass Then if Mid$(hx$, i, 1 )="0" Else bypass=false
If bypass and i<>Len(hx$) Then Continue
Ret$ += One$( EVal( "0x" + Mid$(hx$, i, 1 ) ) )
Next i
oct=instr(Ret$, "1")
if oct=0 then {
Ret$="0"
} Else Ret$=mid$(Ret$, oct)
} Else {
For i= oct to len(hx$)
Ret$ += One$( EVal( "0x" + Mid$(hx$, i, 1 ) ) )
Next i
}
=Ret$
}
}
Bin$=BinFunc$()
Stack New {
Data 9, 50, 9000
While not empty {
Read x
Print Format$("The decimal value {0::-10} should produce an output of {1:-32}",x, Bin$(x) )
}
}
Stack New {
Data 9, 50, 9000
While not empty {
Read x
Print Format$("The decimal value {0::-10} should produce an output of {1:-32}",x, Bin$(x,,false) )
}
}
Stack New {
Data 9, 50, 9000
While not empty {
Read x
Print Bin$(x)
}
}
}
Checkit
</syntaxhighlight>
{{out}}
<pre style="height:30ex;overflow:scroll">
The decimal value 9 should produce an output of 1001
The decimal value 50 should produce an output of 110010
The decimal value 9000 should produce an output of 10001100101000
The decimal value 9 should produce an output of 00000000000000000000000000001001
The decimal value 50 should produce an output of 00000000000000000000000000110010
The decimal value 9000 should produce an output of 00000000000000000010001100101000
1001
110010
10001100101000
</pre >
=={{header|MACRO-11}}==
<syntaxhighlight lang="macro11"> .TITLE BINARY
.MCALL .TTYOUT,.EXIT
BINARY::MOV #3$,R5
BR 2$
1$: JSR PC,PRBIN
2$: MOV (R5)+,R0
BNE 1$
.EXIT
3$: .WORD ^D5, ^D50, ^D9000, 0
; PRINT R0 AS BINARY WITH NEWLINE
PRBIN: MOV #3$,R1
1$: MOV #'0,R2
ROR R0
ADC R2
MOVB R2,(R1)+
TST R0
BNE 1$
2$: MOVB -(R1),R0
.TTYOUT
BNE 2$
RTS PC
.BYTE 0,0,12,15
3$: .BLKB 16 ; BUFFER
.END BINARY</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|MAD}}==
MAD has basically no support for runtime generation of strings.
Therefore, this program works by calculating an integer whose decimal representation
matches the binary representation of the input, e.g. <code>BINARY.(5)</code> is <code>101</code>.
<syntaxhighlight lang="mad"> NORMAL MODE IS INTEGER
INTERNAL FUNCTION(NUM)
ENTRY TO BINARY.
BTEMP = NUM
BRSLT = 0
BDIGIT = 1
BIT WHENEVER BTEMP.NE.0
BRSLT = BRSLT + BDIGIT * (BTEMP-BTEMP/2*2)
BTEMP = BTEMP/2
BDIGIT = BDIGIT * 10
TRANSFER TO BIT
END OF CONDITIONAL
FUNCTION RETURN BRSLT
END OF FUNCTION
THROUGH SHOW, FOR VALUES OF N = 5, 50, 9000
SHOW PRINT FORMAT FMT, N, BINARY.(N)
VECTOR VALUES FMT = $I4,2H: ,I16*$
END OF PROGRAM </syntaxhighlight>
{{out}}
<pre> 5: 101
50: 110010
9000: 10001100101000</pre>
=={{header|Maple}}==
<syntaxhighlight lang="maple">
> convert( 50, 'binary' );
110010
> convert( 9000, 'binary' );
10001100101000
</syntaxhighlight>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
=={{header|MATLAB}} / {{header|Octave}}==
<
dec2bin(50)
dec2bin(9000) </
The output is a string containing ascii(48) (i.e. '0') and ascii(49) (i.e. '1').
=={{header|Maxima}}==
<
[n: first(arg), b: if length(arg) > 1 then second(arg) else 10, v: [ ], q],
do (
Line 1,678 ⟶ 3,639:
/*
10001100101000
*/</
=={{header|MAXScript}}==
<syntaxhighlight lang="maxscript">
-- MAXScript: Output decimal numbers from 0 to 16 as Binary : N.H. 2019
for k = 0 to 16 do
(
temp = ""
binString = ""
b = k
-- While loop wont execute for zero so force string to zero
if b == 0 then temp = "0"
while b > 0 do
(
rem = b
b = b / 2
If ((mod rem 2) as Integer) == 0 then temp = temp + "0"
else temp = temp + "1"
)
-- Reverse the binary string
for r = temp.count to 1 by -1 do
(
binString = binString + temp[r]
)
print binString
)
</syntaxhighlight>
{{out}}
Output to MAXScript Listener:
<pre>
"0"
"1"
"10"
"11"
"100"
"101"
"110"
"111"
"1000"
"1001"
"1010"
"1011"
"1100"
"1101"
"1110"
"1111"
"10000"
</pre>
=={{header|Mercury}}==
<
:- interface.
Line 1,697 ⟶ 3,703:
print_binary_digits(N, !IO) :-
io.write_string(int_to_base_string(N, 2), !IO),
io.nl(!IO).</
=={{header|min}}==
{{works with|min|0.37.0}}
<syntaxhighlight lang="min">(
symbol bin
(int :i ==> str :s)
(i (dup 2 <) 'string ('odd? ("1") ("0") if swap 1 shr) 'prefix linrec @s)
) ::
(0 1 2 5 50 9000) 'bin map ", " join puts!</syntaxhighlight>
{{out}}
<pre>0, 1, 10, 101, 110010, 10001100101000</pre>
=={{header|MiniScript}}==
=== Iterative ===
<syntaxhighlight lang="miniscript">binary = function(n)
result = ""
while n
result = str(n%2) + result
n = floor(n/2)
end while
if not result then return "0"
return result
end function
print binary(5)
print binary(50)
print binary(9000)
print binary(0)</syntaxhighlight>
=== Recursive ===
<syntaxhighlight lang="miniscript">binary = function(n,result="")
if n == 0 then
if result == "" then return "0" else return result
end if
result = str(n%2) + result
return binary(floor(n/2),result)
end function
print binary(5)
print binary(50)
print binary(9000)
print binary(0)</syntaxhighlight>
{{out}}
<pre>
101
110010
10001100101000
0
</pre>
=={{header|mLite}}==
<
(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, [])
;
</syntaxhighlight>
==== from the REPL ====
Line 1,715 ⟶ 3,770:
> binary 9000;
"10001100101000"</pre>
=={{header|Modula-2}}==
<syntaxhighlight lang="modula2">MODULE Binary;
FROM FormatString IMPORT FormatString;
FROM Terminal IMPORT Write,WriteLn,ReadChar;
PROCEDURE PrintByte(b : INTEGER);
VAR v : INTEGER;
BEGIN
v := 080H;
WHILE v#0 DO
IF (b BAND v) # 0 THEN
Write('1')
ELSE
Write('0')
END;
v := v SHR 1
END
END PrintByte;
VAR
buf : ARRAY[0..15] OF CHAR;
i : INTEGER;
BEGIN
FOR i:=0 TO 15 DO
PrintByte(i);
WriteLn
END;
ReadChar
END Binary.</syntaxhighlight>
=={{header|Modula-3}}==
<
IMPORT IO, Fmt;
Line 1,727 ⟶ 3,811:
num := 150;
IO.Put(Fmt.Int(num, 2) & "\n");
END Binary.</
{{out}}
<pre>
1010
10010110
</pre>
=={{header|NetRexx}}==
<
options replace format comments java crossref symbols nobinary
Line 1,752 ⟶ 3,835:
w_ = list.word(n_)
say w_.right(20)':' getBinaryDigits(w_)
end n_</
{{out}}
<pre>
Line 1,760 ⟶ 3,843:
9000: 10001100101000
</pre>
=={{header|NewLisp}}==
<syntaxhighlight lang="newlisp">
;;; Using the built-in "bits" function
;;; For integers up to 9,223,372,036,854,775,807
(map println (map bits '(0 5 50 9000)))
;;; n > 0, "unlimited" size
(define (big-bits n)
(let (res "")
(while (> n 0)
(push (if (even? n) "0" "1") res)
(setq n (/ n 2)))
res))
;;; Example
(println (big-bits 1234567890123456789012345678901234567890L))
</syntaxhighlight>
<pre>
Output:
0
101
110010
10001100101000
1110100000110010010010000001110101110000001101101111110011101110001010110010111100010111111001011011001110001111110000101011010010
</pre>
=={{header|Nickle}}==
Using the Nickle output radix operator:
<pre>prompt$ nickle
> 0 # 2
0
> 5 # 2
101
> 50 # 2
110010
> 9000 # 2
10001100101000</pre>
=={{header|Nim}}==
<
## Calculates how many digits `x` has when each digit covers `r` bits.
result = 1
Line 1,785 ⟶ 3,903:
for i in 0..15:
echo toBin(i)</
{{out}}
<pre>0
1
Line 1,804 ⟶ 3,922:
1111</pre>
===Version using strformat===
<syntaxhighlight lang="nim">import strformat
for n in 0..15:
echo fmt"{n:b}"</syntaxhighlight>
{{out}}
<pre>0
1
10
11
100
101
110
111
1000
1001
1010
1011
1100
1101
1110
1111</pre>
=={{header|Oberon-2}}==
<
MODULE BinaryDigits;
IMPORT Out;
Line 1,823 ⟶ 3,964:
OutBin(42); Out.Ln;
END BinaryDigits.
</syntaxhighlight>
{{out}}
Line 1,833 ⟶ 3,974:
101010
</pre>
=={{header|Objeck}}==
<
function : Main(args : String[]) ~ Nil {
5->ToBinaryString()->PrintLine();
Line 1,841 ⟶ 3,981:
9000->ToBinaryString()->PrintLine();
}
}</
{{out}}
<pre>
101
Line 1,849 ⟶ 3,988:
10001100101000
</pre>
=={{header|OCaml}}==
<
let last_digit n = [|"0"; "1"|].(n land 1) in
let rec aux lst = function
in
String.concat "" (aux [last_digit d] (d lsr 1))
(* test *)
|> List.map bin_of_int |> String.concat ", " |> print_endline</syntaxhighlight>
The output of negative integers is interesting, as it shows the [[wp:Two's_complement|two's complement]] representation and the width of Int on the system.
{{out}}
<pre>
0, 1, 10, 101, 110010, 10001100101000, 1111111111111111111111111111011
</pre>
=={{header|Oforth}}==
Line 1,881 ⟶ 4,023:
ok
</pre>
=={{header|Ol}}==
<syntaxhighlight lang="scheme">
(print (number->string 5 2))
(print (number->string 50 2))
(print (number->string 9000 2))
</syntaxhighlight>
{{Out}}
<pre>
101
110010
10001100101000
</pre>
=={{header|OxygenBasic}}==
The Assembly code uses block structures to minimise the use of labels.
<
function BinaryBits(sys n) as string
Line 1,928 ⟶ 4,081:
print BinaryBits 0xaa 'result 10101010
</syntaxhighlight>
=={{header|Panda}}==
<syntaxhighlight lang
{{out}}
<pre>0
1
Line 1,952 ⟶ 4,101:
1110
1111</pre>
=={{header|PARI/GP}}==
<syntaxhighlight lang="parigp">bin(n:int)=concat(apply(s->Str(s),binary(n)))</syntaxhighlight>
=={{header|Pascal}}==
{{works with|Free Pascal}}
FPC compiler Version 2.6 upwards.The obvious version.
<
{$MODE objFPC}
uses
Line 1,983 ⟶ 4,134:
IntBinTest(5);IntBinTest(50);IntBinTest(5000);
IntBinTest(0);IntBinTest(NativeUint(-1));
end.</
{{out}}
<pre> 5 101
50 110010
Line 1,995 ⟶ 4,146:
Beware of the endianess of the constant.
I check performance with random Data.
<
program IntToPcharTest;
uses
Line 2,101 ⟶ 4,252:
Writeln(cnt/rounds+1:6:3);
FreeMem(s);
end.</
{{out}}
<pre>
//32-Bit fpc 3.1.1 -O3 -XX -Xs Cpu i4330 @3.5 Ghz
Line 2,115 ⟶ 4,266:
Time 0.175 secs, average stringlength 62.000
..the obvious version takes about 1.1 secs generating the string takes most of the time..</pre>
=={{header|PascalABC.NET}}==
<syntaxhighlight lang="pascal">
begin
foreach var number in |5, 50, 9000| do
Writeln($'{number,4} - {Convert.ToString(number,2)}');
end.
</syntaxhighlight>
{{out}}
<pre>
5 - 101
50 - 110010
9000 - 10001100101000
</pre>
=={{header|Peloton}}==
<
<@ saybaslit>0</@>
Line 2,123 ⟶ 4,287:
<@ saybaslit>50</@>
<@ saybaslit>9000</@>
</syntaxhighlight>
=={{header|Perl}}==
<
printf "%b\n", $_;
}</
<pre>
101
Line 2,134 ⟶ 4,298:
10001100101000
</pre>
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%b\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%b\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">50</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%b\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9000</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 2,154 ⟶ 4,310:
10001100101000
</pre>
=={{header|Phixmonti}}==
<syntaxhighlight lang="phixmonti">def printBinary
"The decimal value " print dup print " should produce an output of " print
20 int>bit
len 1 -1 3 tolist
for
get not
if
-1 del
else
exitfor
endif
endfor
len 1 -1 3 tolist
for
get print
endfor
nl
enddef
5 printBinary
50 printBinary
9000 printBinary</syntaxhighlight>
Other solution
<syntaxhighlight lang="phixmonti">/# Rosetta Code problem: http://rosettacode.org/wiki/Binary_digits
by Galileo, 05/2022 #/
include ..\Utilitys.pmt
def printBinary
0 >ps >ps
( "The decimal value " tps " should produce an output of " ) lprint
ps> 20 int>bit
( len 1 -1 ) for
get dup ps> or if print 1 >ps else drop 0 >ps endif
endfor
nl
enddef
5 printBinary
50 printBinary
9000 printBinary
</syntaxhighlight>
{{out}}
<pre>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
=== Press any key to exit ===</pre>
=={{header|PHP}}==
<
echo decbin(5);
echo decbin(50);
echo decbin(9000);</
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|Picat}}==
<syntaxhighlight lang="picat"> foreach(I in [5,50,900])
println(to_binary_string(I))
end.</syntaxhighlight>
{{out}}
<pre>101
110010
1110000100</pre>
=={{header|PicoLisp}}==
<
-> "101"
Line 2,173 ⟶ 4,387:
: (bin 9000)
-> "10001100101000"</
=={{header|Piet}}==
Line 2,332 ⟶ 4,545:
Explanation of program flow and image download link on my user page: [http://rosettacode.org/wiki/User:Albedo#Binary_Digits]
=={{header|PL/I}}==
Displays binary output trivially, but with leading zeros:
<
{{out}}
<pre>Output: 0011001
</pre>
With leading zero suppression:
<
put string(text) edit (25) (b);
Line 2,345 ⟶ 4,558:
put string(text) edit (2147483647) (b);
put skip list (trim(text, '0'));</
{{out}}
<pre>
Line 2,351 ⟶ 4,564:
1111111111111111111111111111111
</pre>
=={{header|PL/M}}==
<syntaxhighlight lang="plm">100H:
/* CP/M BDOS CALL */
BDOS: PROCEDURE (FN, ARG);
DECLARE FN BYTE, ARG ADDRESS;
GO TO 5;
END BDOS;
/* PRINT STRING */
PRINT: PROCEDURE (STRING);
DECLARE STRING ADDRESS;
CALL BDOS(9, STRING);
END PRINT;
/* PRINT BINARY NUMBER */
PRINT$BINARY: PROCEDURE (N);
DECLARE S (19) BYTE INITIAL ('................',13,10,'$');
DECLARE (N, P) ADDRESS, C BASED P BYTE;
P = .S(16);
BIT:
P = P - 1;
C = (N AND 1) + '0';
IF (N := SHR(N,1)) <> 0 THEN GO TO BIT;
CALL PRINT(P);
END PRINT$BINARY;
/* EXAMPLES FROM TASK */
DECLARE TEST (3) ADDRESS INITIAL (5, 50, 9000);
DECLARE I BYTE;
DO I = 0 TO LAST(TEST);
CALL PRINT$BINARY(TEST(I));
END;
CALL BDOS(0,0);
EOF</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|PowerBASIC}}==
Pretty simple task in PowerBASIC since it has a built-in BIN$-Function. Omitting the second parameter ("Digits") means no leading zeros in the result.
<syntaxhighlight lang="powerbasic">
#COMPILE EXE
#DIM ALL
#COMPILER PBCC 6
FUNCTION PBMAIN () AS LONG
LOCAL i, d() AS DWORD
REDIM d(2)
ARRAY ASSIGN d() = 5, 50, 9000
FOR i = 0 TO 2
PRINT STR$(d(i)) & ": " & BIN$(d(i)) & " (" & BIN$(d(i), 32) & ")"
NEXT i
END FUNCTION</syntaxhighlight>
{{out}}<pre>
5: 101 (00000000000000000000000000000101)
50: 110010 (00000000000000000000000000110010)
9000: 10001100101000 (00000000000000000010001100101000)
</pre>
=={{header|PowerShell}}==
{{libheader|Microsoft .NET Framework}}
<
{{out}}
<pre>101
110010
1110000100</pre>
=={{header|Processing}}==
<syntaxhighlight lang="processing">println(Integer.toBinaryString(5)); // 101
println(Integer.toBinaryString(50)); // 110010
println(Integer.toBinaryString(9000)); // 10001100101000</syntaxhighlight>
Processing also has a binary() function, but this returns zero-padded results
<syntaxhighlight lang="processing">println(binary(5)); // 00000000000101
println(binary(50)); // 00000000110010
println(binary(9000)); // 10001100101000</syntaxhighlight>
=={{header|Prolog}}==
{{works with|SWI Prolog}}
{{works with|GNU Prolog}}
<
binary(X) :- format('~2r~n', [X]).
main :- maplist(binary, [5,50,9000]), halt.
</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|PureBasic}}==
<
PrintN(Bin(5)) ;101
PrintN(Bin(50)) ;110010
Line 2,379 ⟶ 4,659:
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|Python}}==
===String.format() method===
{{works with|Python|3.X and 2.6+}}
<
0
Line 2,404 ⟶ 4,684:
1101
1110
1111</
===Built-in bin() function===
{{works with|Python|3.X and 2.6+}}
<
0
1
10
11
100
101
110
111
1000
1001
1010
1011
1100
1101
1110
1111</syntaxhighlight>
Pre-Python 2.6:
<
>>> bin = lambda n: ''.join(oct2bin[octdigit] for octdigit in '%o' % n).lstrip('0') or '0'
>>> for i in range(16): print(bin(i))
Line 2,444 ⟶ 4,726:
1101
1110
1111</
===Custom functions===
Defined in terms of a more general '''showIntAtBase''' function:
<syntaxhighlight lang="python">'''Binary strings for integers'''
# showBinary :: Int -> String
def showBinary(n):
'''Binary string representation of an integer.'''
def binaryChar(n):
return '1' if n != 0 else '0'
return showIntAtBase(2)(binaryChar)(n)('')
# TEST ----------------------------------------------------
# main :: IO()
def main():
'''Test'''
print('Mapping showBinary over integer list:')
print(unlines(map(
showBinary,
[5, 50, 9000]
)))
print(tabulated(
'\nUsing showBinary as a display function:'
)(str)(showBinary)(
lambda x: x
)([5, 50, 9000]))
# GENERIC -------------------------------------------------
# compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
def compose(g):
'''Right to left function composition.'''
return lambda f: lambda x: g(f(x))
# enumFromTo :: (Int, Int) -> [Int]
def enumFromTo(m):
'''Integer enumeration from m to n.'''
return lambda n: list(range(m, 1 + n))
# showIntAtBase :: Int -> (Int -> String) -> Int -> String -> String
def showIntAtBase(base):
'''String representing a non-negative integer
using the base specified by the first argument,
and the character representation specified by the second.
The final argument is a (possibly empty) string to which
the numeric string will be prepended.'''
def wrap(toChr, n, rs):
def go(nd, r):
n, d = nd
r_ = toChr(d) + r
return go(divmod(n, base), r_) if 0 != n else r_
return 'unsupported base' if 1 >= base else (
'negative number' if 0 > n else (
go(divmod(n, base), rs))
)
return lambda toChr: lambda n: lambda rs: (
wrap(toChr, n, rs)
)
# tabulated :: String -> (a -> String) ->
# (b -> String) ->
# (a -> b) -> [a] -> String
def tabulated(s):
'''Heading -> x display function -> fx display function ->
f -> value list -> tabular string.'''
def go(xShow, fxShow, f, xs):
w = max(map(compose(len)(xShow), xs))
return s + '\n' + '\n'.join(
xShow(x).rjust(w, ' ') + ' -> ' + fxShow(f(x)) for x in xs
)
return lambda xShow: lambda fxShow: lambda f: lambda xs: go(
xShow, fxShow, f, xs
)
# unlines :: [String] -> String
def unlines(xs):
'''A single string derived by the intercalation
of a list of strings with the newline character.'''
return '\n'.join(xs)
if __name__ == '__main__':
main()</syntaxhighlight>
{{Out}}
<pre>Mapping showBinary over integer list:
101
110010
10001100101000
Using showBinary as a display function:
5 -> 101
50 -> 110010
9000 -> 10001100101000</pre>
Or, using a more specialised function to decompose an integer to a list of boolean values:
<syntaxhighlight lang="python">'''Decomposition of an integer to a string of booleans.'''
# boolsFromInt :: Int -> [Bool]
def boolsFromInt(n):
'''List of booleans derived by binary
decomposition of an integer.'''
def go(x):
(q, r) = divmod(x, 2)
return Just((q, bool(r))) if x else Nothing()
return unfoldl(go)(n)
# stringFromBools :: [Bool] -> String
def stringFromBools(xs):
'''Binary string representation of a
list of boolean values.'''
def oneOrZero(x):
return '1' if x else '0'
return ''.join(map(oneOrZero, xs))
# TEST ----------------------------------------------------
# main :: IO()
def main():
'''Test'''
binary = compose(stringFromBools)(boolsFromInt)
print('Mapping a composed function:')
print(unlines(map(
binary,
[5, 50, 9000]
)))
print(
tabulated(
'\n\nTabulating a string display from binary data:'
)(str)(stringFromBools)(
boolsFromInt
)([5, 50, 9000])
)
# GENERIC -------------------------------------------------
# Just :: a -> Maybe a
def Just(x):
'''Constructor for an inhabited Maybe (option type) value.'''
return {'type': 'Maybe', 'Nothing': False, 'Just': x}
# Nothing :: Maybe a
def Nothing():
'''Constructor for an empty Maybe (option type) value.'''
return {'type': 'Maybe', 'Nothing': True}
# compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
def compose(g):
'''Right to left function composition.'''
return lambda f: lambda x: g(f(x))
# enumFromTo :: (Int, Int) -> [Int]
def enumFromTo(m):
'''Integer enumeration from m to n.'''
return lambda n: list(range(m, 1 + n))
# tabulated :: String -> (a -> String) ->
# (b -> String) ->
# (a -> b) -> [a] -> String
def tabulated(s):
'''Heading -> x display function -> fx display function ->
f -> value list -> tabular string.'''
def go(xShow, fxShow, f, xs):
w = max(map(compose(len)(xShow), xs))
return s + '\n' + '\n'.join(
xShow(x).rjust(w, ' ') + ' -> ' + fxShow(f(x)) for x in xs
)
return lambda xShow: lambda fxShow: lambda f: lambda xs: go(
xShow, fxShow, f, xs
)
# unfoldl(lambda x: Just(((x - 1), x)) if 0 != x else Nothing())(10)
# -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# unfoldl :: (b -> Maybe (b, a)) -> b -> [a]
def unfoldl(f):
'''Dual to reduce or foldl.
Where these reduce a list to a summary value, unfoldl
builds a list from a seed value.
Where f returns Just(a, b), a is appended to the list,
and the residual b is used as the argument for the next
application of f.
When f returns Nothing, the completed list is returned.'''
def go(v):
xr = v, v
xs = []
while True:
mb = f(xr[0])
if mb.get('Nothing'):
return xs
else:
xr = mb.get('Just')
xs.insert(0, xr[1])
return xs
return lambda x: go(x)
# unlines :: [String] -> String
def unlines(xs):
'''A single string derived by the intercalation
of a list of strings with the newline character.'''
return '\n'.join(xs)
# MAIN -------------------------------------------------
if __name__ == '__main__':
main()</syntaxhighlight>
{{Out}}
<pre>Mapping a composed function:
101
110010
10001100101000
Tabulating a string display from binary data:
5 -> 101
50 -> 110010
9000 -> 10001100101000</pre>
=={{header|QB64}}==
<syntaxhighlight lang="qb64">
Print DecToBin$(5)
Print DecToBin$(50)
Print DecToBin$(9000)
Print BinToDec$(DecToBin$(5)) ' 101
Print BinToDec$(DecToBin$(50)) '110010
Print BinToDec$(DecToBin$(9000)) ' 10001100101000
End
Function DecToBin$ (digit As Integer)
DecToBin$ = "Error"
If digit < 1 Then
Print " Error number invalid for conversion to binary"
DecToBin$ = "error of input"
Exit Function
Else
Dim As Integer TempD
Dim binaryD As String
binaryD = ""
TempD = digit
Do
binaryD = Right$(Str$(TempD Mod 2), 1) + binaryD
TempD = TempD \ 2
Loop Until TempD = 0
DecToBin$ = binaryD
End If
End Function
Function BinToDec$ (digitB As String)
BinToDec$ = "Error"
If Len(digitB) < 1 Then
Print " Error number invalid for conversion to decimal"
BinToDec$ = "error of input"
Exit Function
Else
Dim As Integer TempD
Dim binaryD As String
binaryD = digitB
TempD = 0
Do
TempD = TempD + ((2 ^ (Len(binaryD) - 1)) * Val(Left$(binaryD, 1)))
binaryD = Right$(binaryD, Len(binaryD) - 1)
Loop Until Len(binaryD) = 0
BinToDec$ = LTrim$(Str$(TempD))
End If
End Function
</syntaxhighlight>
=={{header|Quackery}}==
Quackery provides built-in radix control, much like Forth.
<syntaxhighlight lang="quackery">
2 base put ( Numbers will be output in base 2 now. )
( Bases from 2 to 36 (inclusive) are supported. )
5 echo cr
50 echo cr
9000 echo cr
base release ( It's best to clean up after ourselves. )
( Numbers will be output in base 10 now. )
</syntaxhighlight>
A user-defined conversion might look something like this:
<syntaxhighlight lang="quackery">
[ [] swap
[ 2 /mod digit
swap dip join
dup not until ]
drop reverse ] is bin ( n --> $ )
5 bin echo$ cr
50 bin echo$ cr
9000 bin echo$ cr
</syntaxhighlight>
{{out}}
<pre>
101
110010
10001100101000
</pre>
=={{header|R}}==
<syntaxhighlight lang="rsplus">
dec2bin <- function(num) {
ifelse(num == 0,
0,
sub("^0+","",paste(rev(as.integer(intToBits(num))), collapse = ""))
)
}
for (anumber in c(0, 5, 50, 9000)) {
cat(dec2bin(anumber),"\n")
}
</syntaxhighlight>
'''output'''
<pre>
0
101
110010
10001100101000
</pre>
=={{header|Racket}}==
<
#lang racket
;; Option 1: binary formatter
Line 2,453 ⟶ 5,078:
;; Option 2: explicit conversion
(for ([i 16]) (displayln (number->string i 2)))
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|2015.12}}
<syntaxhighlight lang="raku" line>say .fmt("%b") for 5, 50, 9000;</syntaxhighlight>
<pre>
101
110010
10001100101000
</pre>
Alternatively:
<syntaxhighlight lang="raku" line>say .base(2) for 5, 50, 9000;</syntaxhighlight>
<pre>101
110010
10001100101000</pre>
=={{header|RapidQ}}==
<syntaxhighlight lang="vb">
'Convert Integer to binary string
Print "bin 5 = ", bin$(5)
Line 2,463 ⟶ 5,102:
Print "bin 9000 = ",bin$(9000)
sleep 10
</syntaxhighlight>
=={{header|Red}}==
<syntaxhighlight lang="red">Red []
foreach number [5 50 9000] [
;; any returns first not false value, used to cut leading zeroes
binstr: form any [find enbase/base to-binary number 2 "1" "0"]
print reduce [ pad/left number 5 binstr ]
]
</syntaxhighlight>
'''output'''
<pre> 5 101
50 110010
9000 10001100101000
</pre>
=={{header|Retro}}==
<
=={{header|Refal}}==
<syntaxhighlight lang="refal">$ENTRY Go {
= <Prout <Binary 5>
<Binary 50>
<Binary 9000>>;
};
Binary {
0 = '0\n';
s.N = <Binary1 s.N> '\n';
};
Binary1 {
0 = ;
s.N, <Divmod s.N 2>: (s.R) s.D = <Binary1 s.R> <Symb s.D>;
};</syntaxhighlight>
{{out}
<pre>101
110010
10001100101000</pre>
=={{header|REXX}}==
Line 2,473 ⟶ 5,145:
Note: some REXX interpreters have a '''D2B''' [Decimal to Binary] BIF ('''b'''uilt-'''i'''n '''f'''unction).
<br>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).
<
numeric digits 1000 /*ensure we can handle larger numbers. */
@.=; @.1= 0
Line 2,483 ⟶ 5,155:
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. */</
<pre>
0 decimal, and in binary: 0
Line 2,495 ⟶ 5,167:
This version handles the case of zero as a special case more elegantly.
<br>The following versions depend on the setting of '''numeric digits''' such that the number in decimal can be expressed as a whole number.
<
@.=; @.1= 0
@.2= 5
Line 2,505 ⟶ 5,177:
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. */</
===concise version===
This version handles the case of zero a bit more obtusely, but concisely.
<
@.=; @.1= 0
@.2= 5
Line 2,519 ⟶ 5,191:
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. */</
===conforming version===
This REXX version conforms to the strict output requirements of this task (just show the binary output without any blanks).
<
numeric digits 200 /*ensure we can handle larger numbers. */
@.=; @.1= 0
Line 2,536 ⟶ 5,208:
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
end /*j*/ /*stick a fork in it, we're all done. */</
<pre>
0
Line 2,549 ⟶ 5,221:
=={{header|Ring}}==
<
see "Number to convert : "
give a
Line 2,562 ⟶ 5,234:
else see 0 ok
next
</syntaxhighlight>
=={{header|Roc}}==
<syntaxhighlight lang="roc">binstr : Int * -> Str
binstr = \n ->
if n < 2 then
Num.toStr n
else
Str.concat (binstr (Num.shiftRightZfBy n 1)) (Num.toStr (Num.bitwiseAnd n 1))</syntaxhighlight>
=={{header|RPL}}==
RPL handles both floating point numbers and binary integers, but the latter are visualized with a <code>#</code> at the beginning and a specific letter at the end identifying the number base, according to the current display mode setting. 42 will then be displayed # 42d, # 2Ah, # 52o or # 101010b depending on the display mode set by resp. <code>DEC</code>, <code>HEX</code>, <code>OCT</code> or <code>BIN</code>.
To comply with the task, we have just to remove these characters.
{{works with|Halcyon Calc|4.2.7}}
≪ BIN R→B →STR 3 OVER SIZE 1 - SUB ≫
'→PLNB' STO
{{in}}
<pre>
5 →PLNB
50 →PLNB
9000 →PLNB
</pre>
{{out}}
<pre>
3: "101"
2: "110010"
1: "10001100101000"
</pre>
=={{header|Ruby}}==
<
puts "%b" % n
end</
or
<
puts n.to_s(2)
end</
{{out}}
<pre>101
110010
Line 2,578 ⟶ 5,278:
=={{header|Run BASIC}}==
<
while 2^(n+1) < a
n = n + 1
Line 2,591 ⟶ 5,291:
print 0;
end if
next</
{{out}}
<pre>Number to convert:?9000
10001100101000</pre>
=={{header|Rust}}==
<
for i in 0..8 {
println!("{:b}", i)
}
}</
Outputs:
<pre>0
Line 2,611 ⟶ 5,310:
110
111</pre>
=={{header|S-lang}}==
<
{
variable m = 0x40000000, prn = 0, bs = "";
Line 2,634 ⟶ 5,331:
() = printf("%s\n", int_to_bin(5));
() = printf("%s\n", int_to_bin(50));
() = printf("%s\n", int_to_bin(9000));</
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|S-BASIC}}==
<syntaxhighlight lang = "BASIC">
rem - Return binary representation of n
function bin$(n = integer) = string
var s = string
s = ""
while n > 0 do
begin
if (n - (n / 2) * 2) = 0 then
s = "0" + s
else
s = "1" + s
n = n / 2
end
end = s
rem - exercise the function
print "5 = "; bin$(5)
print "50 = "; bin$(50)
print "9000 = "; bin$(9000)
end
</syntaxhighlight>
{{out}}
<pre>
5 = 101
50 = 110010
9000 = 10001100101000
</pre>
=={{header|Scala}}==
Scala has an implicit conversion from <code>Int</code> to <code>RichInt</code> which has a method <code>toBinaryString</code>.
<
res0: String = 101
Line 2,649 ⟶ 5,379:
scala> (9000 toBinaryString)
res2: String = 10001100101000</
=={{header|Scheme}}==
<
(display (number->string 50 2)) (newline)
(display (number->string 9000 2)) (newline)</
=={{header|sed}}==
<syntaxhighlight lang="sed">: a
s/^0*/d/
/^d[1-9]/t b
b e
: b
s/d[01]/0&/
s/d[23]/1&/
s/d[45]/2&/
s/d[67]/3&/
s/d[89]/4&/
t d
b a
: c
s/D[01]/5&/
s/D[23]/6&/
s/D[45]/7&/
s/D[67]/8&/
s/D[89]/9&/
t d
b a
: d
s/[dD][02468]/d/
t b
s/[dD][13579]/D/
t c
: e
s/^dD/D/
y/dD/01/</syntaxhighlight>
{{out}}
<pre>
$ echo $(seq 0 16 | sed -f binary-digits.sed)
0 1 10 11 100 101 110 111 1000 1001 1010 1011 1100 1101 1110 1111 10000
$ printf '%s\n' 50 9000 1996677482718355282095361651 | sed -f binary-digits.sed
110010
10001100101000
1100111001110011100111001110011100111001110011100111001110011100111001110011100111001110011
</pre>
=={{header|Seed7}}==
This example uses the [http://seed7.sourceforge.net/libraries/integer.htm#%28in_integer%29radix%28in_integer%29 radix] operator to write a number in binary.
<
const proc: main is func
Line 2,668 ⟶ 5,436:
writeln(number radix 2);
end for;
end func;</
{{out}}
<pre>
0
Line 2,690 ⟶ 5,458:
</pre>
=={{header|
<syntaxhighlight lang="setl">program binary_digits;
loop for n in [5, 50, 9000] do
print(bin n);
end loop;
op bin(n);
return reverse +/[str [n mod 2, n div:=2](1) : until n=0];
end op;
end program;</syntaxhighlight>
{{out}}
<pre>101
Line 2,700 ⟶ 5,474:
=={{header|SequenceL}}==
<
toBinaryString(number(0)) :=
Line 2,708 ⟶ 5,482:
toBinaryString(floor(number/2)) ++ val when floor(number/2) > 0
else
val;</
{{out}}
Line 2,715 ⟶ 5,489:
</pre>
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">[5, 50, 9000].each { |n|
say n.as_bin;
}</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|Simula}}==
<syntaxhighlight lang="simula">BEGIN
PROCEDURE OUTINTBIN(N); INTEGER N;
BEGIN
IF N > 1 THEN OUTINTBIN(N//2);
OUTINT(MOD(N,2),1);
END OUTINTBIN;
INTEGER SAMPLE;
FOR SAMPLE := 5, 50, 9000 DO BEGIN
OUTINTBIN(SAMPLE);
OUTIMAGE;
END;
END</syntaxhighlight>
{{out}}
<pre>
101
110010
10001100101000
</pre>
=={{header|SkookumScript}}==
<
println(50.binary)
println(9000.binary)</
Or looping over a list of numbers:
<
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|Smalltalk}}==
<
50 printOn: Stdout radix:2
9000 printOn: Stdout radix:2</
or:
<
=={{header|SNOBOL4}}==
<syntaxhighlight lang="snobol4">
define('bin(n,r)') :(bin_end)
bin bin = le(n,0) r :s(return)
bin = bin(n / 2, REMDR(n,2) r) :(return)
bin_end
output = bin(5)
output = bin(50)
output = bin(9000)
end</syntaxhighlight>
{{out}}
<pre>
101
110010
10001100101000
</pre>
=={{header|SNUSP}}==
<syntaxhighlight lang="snusp">
/recurse\
$,binary!\@\>?!\@/<@\.#
Line 2,742 ⟶ 5,560:
/<+>- \ div2
\?!#-?/+# mod2
</syntaxhighlight>
=={{header|Standard ML}}==
<
print (Int.fmt StringCvt.BIN 50 ^ "\n");
print (Int.fmt StringCvt.BIN 9000 ^ "\n");</
=={{header|Swift}}==
<
println(String(num, radix: 2))
}</
{{out}}
<pre>
Line 2,757 ⟶ 5,574:
110010
10001100101000</pre>
=={{header|Tcl}}==
<
# 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:
<
puts [num2bin $x]
}
Line 2,772 ⟶ 5,588:
puts [num2bin 5]
puts [num2bin 50]
puts [num2bin 9000]</
{{out}}
<pre>
0
Line 2,796 ⟶ 5,612:
10001100101000
</pre>
<br>
Or you can use the builtin format:
<syntaxhighlight lang="tcl">foreach n {0 1 5 50 9000} {
puts [format "%4u: %b" $n $n]
}</syntaxhighlight>
{{out}}
<pre> 0: 0
1: 1
5: 101
50: 110010
9000: 10001100101000</pre>
=={{header|TI-83 BASIC}}==
Using Standard TI-83 BASIC
<
:Disp "NUMBER TO"
:Disp "CONVERT:"
Line 2,817 ⟶ 5,643:
:N-1→N
:End
:Disp B</
Alternate using a string to display larger numbers.
<
:Input X
:" "→Str1
Line 2,827 ⟶ 5,653:
:iPart(X)→X
:End
:Str1</
Using the baseInput() "real(25," function from [http://www.detachedsolutions.com/omnicalc/ Omnicalc]
<
:Disp "NUMBER TO"
:Disp "CONVERT"
:Input "Str1"
:Disp real(25,Str1,10,2)</
More compact version:
<
:" →Str1
:If not(D:"0→Str1
Line 2,848 ⟶ 5,674:
:End
:Disp Str1
</syntaxhighlight>
=={{header|uBasic/4tH}}==
This will convert any decimal number to any base between 2 and 16.
<syntaxhighlight lang="text">Do
Input "Enter base (1<X<17): "; b
While (b < 2) + (b > 16)
Line 2,884 ⟶ 5,709:
130 Print "D"; : Return
140 Print "E"; : Return
150 Print "F"; : Return</
{{out}}
<pre>Enter base (1<X<17): 2
Line 2,891 ⟶ 5,716:
0 OK, 0:775</pre>
=={{header|UNIX Shell}}==
Since POSIX does not specify local variables, make use of <code>set</code> for highest portability.
<syntaxhighlight lang="sh">bin() {
set -- "${1:-0}" ""
do
set -- $(($1 >> 1)) $(($1 & 1))$2
done
echo "$1$2"
}
echo $(for i in 0 1 2 5 50 9000; do bin $i; done)</syntaxhighlight>
{{out}}
<pre>0 1 10 101 110010 10001100101000</pre>
=={{header|VBA}}==
'''2 ways :'''
1- Function DecToBin(ByVal Number As Long) As String
'''Arguments :'''
[Required] Number (Long) : ''should be a positive number''
2- Function DecToBin2(ByVal Number As Long, Optional Places As Long) As String
'''Arguments :'''
[Required] Number (Long) : ''should be >= -512 And <= 511''
[Optional] Places (Long) : ''the number of characters to use.''
Note : If places is omitted, DecToBin2 uses the minimum number of characters necessary.
Places is useful for padding the return value with leading 0s (zeros).
<syntaxhighlight lang="vb">
Option Explicit
Sub Main_Dec2bin()
Dim Nb As Long
Nb = 5
Debug.Print "The decimal value " & Nb & " should produce an output of : " & DecToBin(Nb)
Debug.Print "The decimal value " & Nb & " should produce an output of : " & DecToBin2(Nb)
Nb = 50
Debug.Print "The decimal value " & Nb & " should produce an output of : " & DecToBin(Nb)
Debug.Print "The decimal value " & Nb & " should produce an output of : " & DecToBin2(Nb)
Nb = 9000
Debug.Print "The decimal value " & Nb & " should produce an output of : " & DecToBin(Nb)
Debug.Print "The decimal value " & Nb & " should produce an output of : " & DecToBin2(Nb)
End Sub
Function DecToBin(ByVal Number As Long) As String
Dim strTemp As String
Do While Number > 1
strTemp = Number - 2 * (Number \ 2) & strTemp
Number = Number \ 2
Loop
DecToBin = Number & strTemp
End Function
Function DecToBin2(ByVal Number As Long, Optional Places As Long) As String
If Number > 511 Then
DecToBin2 = "Error : Number is too large ! (Number must be < 511)"
ElseIf Number < -512 Then
DecToBin2 = "Error : Number is too small ! (Number must be > -512)"
Else
If Places = 0 Then
DecToBin2 = WorksheetFunction.Dec2Bin(Number)
Else
DecToBin2 = WorksheetFunction.Dec2Bin(Number, Places)
End If
End If
End Function
</syntaxhighlight>
{{out}}
<pre>The decimal value 5 should produce an output of : 101
The decimal value 5 should produce an output of : 101
The decimal value 50 should produce an output of : 110010
The decimal value 50 should produce an output of : 110010
The decimal value 9000 should produce an output of : 10001100101000
The decimal value 9000 should produce an output of : Error : Number is too large ! (Number must be < 511)</pre>
=={{header|Vedit macro language}}==
This implementation reads the numeric values from user input and writes the converted binary values in the edit buffer.
<
#10 = Get_Num("Give a numeric value, -1 to end: ", STATLINE)
if (#10 < 0) { break }
Line 2,920 ⟶ 5,817:
EOL
Ins_Newline
Return </
Example output when values 0, 1, 5, 50 and 9000 were entered:
<pre>
Line 2,929 ⟶ 5,826:
10001100101000
</pre>
=={{header|Vim Script}}==
<
let n = a:n
let s = ""
Line 2,951 ⟶ 5,847:
echo Num2Bin(5)
echo Num2Bin(50)
echo Num2Bin(9000)</
{{Out}}
Line 2,957 ⟶ 5,853:
110010
10001100101000</pre>
=={{header|Visual Basic}}==
{{works with|Visual Basic|VB6 Standard}}
<syntaxhighlight lang="vb">
Public Function Bin(ByVal l As Long) As String
Dim i As Long
If l Then
If l And &H80000000 Then 'negative number
Bin = "1" & String$(31, "0")
l = l And (Not &H80000000)
For i = 0 To 30
If l And (2& ^ i) Then
Mid$(Bin, Len(Bin) - i) = "1"
End If
Next i
Else 'positive number
Do While l
If l Mod 2 Then
Bin = "1" & Bin
Else
Bin = "0" & Bin
End If
l = l \ 2
Loop
End If
Else
Bin = "0" 'zero
End If
End Function
'testing:
Public Sub Main()
Debug.Print Bin(5)
Debug.Print Bin(50)
Debug.Print Bin(9000)
End Sub
</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|Visual Basic .NET}}==
<
Sub Main
For Each number In {5, 50, 9000}
Console.WriteLine(
Next
End Sub
End Module</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|Visual FoxPro}}==
<
*!* Binary Digits
CLEAR
Line 2,998 ⟶ 5,934:
RETURN FLOOR(v)
ENDFUNC
</syntaxhighlight>
{{out}}
<pre>
Line 3,005 ⟶ 5,941:
10001100101000
</pre>
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">fn main() {
for i in 0..16 {
println("${i:b}")
}
}</syntaxhighlight>
{{out}}
<pre>
0
1
10
11
100
101
110
111
1000
1001
1010
1011
1100
1101
1110
1111
</pre>
=={{header|VTL-2}}==
<syntaxhighlight lang="vtl2">10 N=5
20 #=100
30 N=50
40 #=100
50 N=9000
100 ;=!
110 I=18
120 I=I-1
130 N=N/2
140 :I)=%
150 #=0<N*120
160 ?=:I)
170 I=I+1
180 #=I<18*160
190 ?=""
200 #=;</syntaxhighlight>
{{out}}
<pre>101
110010
10001100101000</pre>
=={{header|VBScript}}==
Using no Math....
<syntaxhighlight lang="vb">
Option Explicit
Dim bin
bin=Array(" "," I"," I "," II"," I "," I I"," II "," III","I ","I I","I I ","I II"," I ","II I","III ","IIII")
Function num2bin(n)
Dim s,i,n1,n2
s=Hex(n)
For i=1 To Len(s)
n1=Asc(Mid(s,i,1))
If n1>64 Then n2=n1-55 Else n2=n1-48
num2bin=num2bin & bin(n2)
Next
num2bin=Replace(Replace(LTrim(num2bin)," ","0"),"I",1)
End Function
Sub print(s):
On Error Resume Next
WScript.stdout.WriteLine (s)
If err= &h80070006& Then WScript.Echo " Please run this script with CScript": WScript.quit
End Sub
print num2bin(5)
print num2bin(50)
print num2bin(9000)
</syntaxhighlight>
{{out}}
<small>
<pre>
101
110010
10001100101000
</pre>
</small>
=={{header|Whitespace}}==
Line 3,010 ⟶ 6,028:
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]].
<syntaxhighlight lang="whitespace">
Line 3,049 ⟶ 6,067:
</
It was generated from the following pseudo-Assembly.
<
; Increment indefinitely.
0:
Line 3,085 ⟶ 6,103:
3:
pop
ret</
=={{header|Wortel}}==
Using JavaScripts buildin toString method on the Number object, the following function takes a number and returns a string with the binary representation:
<
; the following function also casts the string to a number
^(@+ \.toString 2)</
To output to the console:
<
Outputs: <pre>
101
110010
1110000100</pre>
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<syntaxhighlight lang="wren">import "./fmt" for Fmt
System.print("Converting to binary:")
for (i in [5, 50, 9000]) Fmt.print("$d -> $b", i, i)</syntaxhighlight>
{{out}}
<pre>
Converting to binary:
5 -> 101
50 -> 110010
9000 -> 10001100101000
</pre>
=={{header|X86 Assembly}}==
Translation of XPL0. Assemble with tasm, tlink /t
<
.code
.486
Line 3,129 ⟶ 6,161:
int 29h ;display character
ret
end start</
{{out}}
<pre>
101
Line 3,137 ⟶ 6,169:
10001100101000
</pre>
=={{header|XPL0}}==
<
proc BinOut(N); \Output N in binary
Line 3,155 ⟶ 6,186:
I:= I+1;
until KeyHit or I=0;
]</
{{out}}
<pre>
0
Line 3,174 ⟶ 6,205:
100000010100001
</pre>
=={{header|Yabasic}}==
<syntaxhighlight lang="yabasic">dim a(3)
a(0) = 5
a(1) = 50
a(2) = 9000
for i = 0 to 2
print a(i) using "####", " -> ", bin$(a(i))
next i
end</syntaxhighlight>
=={{header|Z80 Assembly}}==
{{trans|8086 Assembly}}
<syntaxhighlight lang="z80">org &8000
PrintChar equ &BB5A ;syscall - prints accumulator to Amstrad CPC's screen
main:
ld hl,TestData0
call PrintBinary_NoLeadingZeroes
ld hl,TestData1
call PrintBinary_NoLeadingZeroes
ld hl,TestData2
call PrintBinary_NoLeadingZeroes
ret
TestData0:
byte 5,255
TestData1:
byte 5,0,255
TestData2:
byte 9,0,0,0,255
temp:
byte 0
;temp storage for the accumulator
; we can't use the stack to preserve A since that would also preserve the flags.
PrintBinary_NoLeadingZeroes:
;setup:
ld bc,&8000 ;B is the revolving bit mask, C is the "have we seen a zero yet" flag
NextDigit:
ld a,(hl)
inc hl
cp 255
jp z,Terminated
ld (temp),a
NextBit:
ld a,(temp)
and b
jr z,PrintZero
; else, print one
ld a,'1' ;&31
call &BB5A
set 0,b ;bit 0 of B is now 1, so we can print zeroes now.
jr Predicate
PrintZero:
ld a,b
or a
jr z,Predicate ;if we haven't seen a zero yet, don't print a zero.
ld a,'0' ;&30
call &BB5A
Predicate:
rrc b
;rotate the mask right by one. If it sets the carry,
; it's back at the start, and we need to load the next byte.
jr nc,NextBit
jr NextDigit ;back to top
Terminated:
ld a,13
call &BB5A
ld a,10
jp &BB5A ;its ret will return for us.</syntaxhighlight>
This is another version. Output of the result over port 0A hex.
<syntaxhighlight lang="z80">
; HL contains the value to be converted
ld hl,5
call binary
ld hl,50
call binary
ld hl,9000
call binary
halt
; Convert to binary
; The OUT(0x0A),A command does the output to an device
binary: push hl
push bc
ld c,0x00
call gobin
ld h,l
call gobin
pop bc
pop hl
ret
gobin: ld b,0x08
bitloop: ld a,h
bit 7,h
jr nz,one
zero: ld a,c
or a
jr z,end1
ld a,"0"
out (0x0a),a
jr end1
one: ld a,"1"
ld c,0x01
out (0x0a),a
end1: ld a,h
rlca
ld h,a
djnz bitloop
ret</syntaxhighlight>
=={{header|zkl}}==
<syntaxhighlight lang="zkl">(9000).toString(2)</syntaxhighlight>
<syntaxhighlight lang="zkl">T(5,50,9000).apply("toString",2) //--> L("101","110010","10001100101000")</syntaxhighlight>
<syntaxhighlight lang="zkl">"%.2B".fmt(9000)</syntaxhighlight>
=={{header|ZX Spectrum Basic}}==
<
20 LET n=50: GO SUB 1000: PRINT s$
30 LET n=9000: GO SUB 1000: PRINT s$
Line 3,194 ⟶ 6,359:
1070 IF (sf <> 0) THEN LET s$=s$+d$
1080 NEXT l
1090 RETURN</
| |||