Binary digits: Difference between revisions

Line 1:

[[Category:Radices]]

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

=={{header|8th}}==

=={{header|0815}}==

2 base drop

<syntaxhighlight lang=0815>}:r:|~ Read numbers in a loop.

#50 . cr

}:b: Treat the queue as a stack and

</syntaxhighlight>

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

<pre>

Note that 0815 reads numeric input in hexadecimal.

<syntaxhighlight lang=bash>echo -e "5\n32\n2329" | 0815 bin.0

101

110010

</pre>

10001100101001</syntaxhighlight>

=={{header|11l}}==

<syntaxhighlight lang=11l>L(n) [0, 5, 50, 9000]

<syntaxhighlight lang="11l">L(n) [0, 5, 50, 9000]

print(‘#4 = #.’.format(n, bin(n)))</syntaxhighlight>

Line 49:

Line 34:

9000 = 10001100101000

</pre>

=={{header|360 Assembly}}==

<syntaxhighlight lang=360asm>* Binary digits 27/08/2015

<syntaxhighlight lang="360asm">* Binary digits 27/08/2015

BINARY CSECT

USING BINARY,R12

Line 101:

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

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

Line 122:

Line 127:

strout = $cb1e

</pre>

; C64 - Binary digits

; http://rosettacode.org/wiki/Binary_digits

Line 228:

Line 233:

100

</pre>

=={{header|8080 Assembly}}==

<syntaxhighlight lang=8080asm>bdos: equ 5h ; CP/M system call

<syntaxhighlight lang="8080asm">bdos: equ 5h ; CP/M system call

puts: equ 9h ; Print string

org 100h

Line 270:

Line 274:

</pre>

=={{header|8086 Assembly}}==

<syntaxhighlight lang=asm> .model small

<syntaxhighlight lang="asm"> .model small

.stack 1024

.data

Line 357:

Line 360:

ret

PrintBinary_NoLeadingZeroes endp</syntaxhighlight>

=={{header|8th}}==

2 base drop

#50 . cr

</syntaxhighlight>

<pre>

110010

</pre>

=={{header|AArch64 Assembly}}==

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program binarydigit.s */

Line 532:

Line 524:

The decimal value +1 should produce an output of 1

</pre>

=={{header|ACL2}}==

<syntaxhighlight lang=~~Lisp~~>(include-book "arithmetic-3/top" :dir :system)

<syntaxhighlight lang="lisp">(include-book "arithmetic-3/top" :dir :system)

(defun bin-string-r (x)

Line 549:

Line 540:

"0"

(bin-string-r x)))</syntaxhighlight>

=={{header|Action!}}==

<syntaxhighlight lang=~~Action~~!>PROC PrintBinary(CARD v)

<syntaxhighlight lang="action!">PROC PrintBinary(CARD v)

CHAR ARRAY a(16)

BYTE i=[0]

Line 590:

Line 580:

Output for 9000 is 10001100101000

</pre>

=={{header|Ada}}==

<syntaxhighlight lang=~~Ada~~>with ada.text_io; use ada.text_io;

<syntaxhighlight lang="ada">with ada.text_io; use ada.text_io;

procedure binary is

bit : array (0..1) of character := ('0','1');

Line 613:

Line 602:

Output for 9000 is 10001100101000

</pre>

=={{header|Aime}}==

<syntaxhighlight lang=aime>o_xinteger(2, 0);

<syntaxhighlight lang="aime">o_xinteger(2, 0);

o_byte('\n');

o_xinteger(2, 5);

Line 627:

Line 615:

110010

10001100101000</pre>

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

{{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'''<syntaxhighlight lang=algol68>#!/usr/local/bin/a68g --script #

'''File: Binary_digits.a68'''<syntaxhighlight lang="algol68">#!/usr/local/bin/a68g --script #

printf((

Line 655:

Line 642:

+9000 => TFFFTTFFTFTFFF

</pre>

=={{header|ALGOL W}}==

<syntaxhighlight lang="algolw">begin

% prints an integer in binary - the number must be greater than zero %

procedure printBinaryDigits( integer value n ) ;

begin

if n not = 0 then begin

printBinaryDigits( n div 2 );

writeon( if n rem 2 = 1 then "1" else "0" )

end

end binaryDigits ;

% prints an integer in binary - the number must not be negative %

procedure printBinary( integer value n ) ;

begin

if n = 0 then writeon( "0" )

else printBinaryDigits( n )

end printBinary ;

% test the printBinaryDigits procedure %

for i := 5, 50, 9000 do begin

write();

printBinary( i );

end

end.</syntaxhighlight>

=={{header|ALGOL-M}}==

<syntaxhighlight lang=algolm>begin

<syntaxhighlight lang="algolm">begin

procedure writebin(n);

integer n;

Line 679:

Line 690:

110010

10001100101000</pre>

=={{header|APL}}==

Works in: [[Dyalog APL]]

A builtin function. Produces a boolean array.

Line 690:

Line 700:

Produces a boolean array.

NOTE: Both versions above will yield an empty boolean array for 0.

Line 704:

Line 714:

1 0 0 0 1 1 0 0 1 0 1 0 0 0

</pre>

=={{header|ALGOL W}}==

<syntaxhighlight lang=algolw>begin

% prints an integer in binary - the number must be greater than zero %

procedure printBinaryDigits( integer value n ) ;

begin

if n not = 0 then begin

printBinaryDigits( n div 2 );

writeon( if n rem 2 = 1 then "1" else "0" )

end

end binaryDigits ;

% prints an integer in binary - the number must not be negative %

procedure printBinary( integer value n ) ;

begin

if n = 0 then writeon( "0" )

else printBinaryDigits( n )

end printBinary ;

% test the printBinaryDigits procedure %

for i := 5, 50, 9000 do begin

write();

printBinary( i );

end

end.</syntaxhighlight>

=={{header|AppleScript}}==

===Functional===

Line 737:

Line 720:

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

<syntaxhighlight lang="applescript">---------------------- BINARY STRING -----------------------

-- showBin :: Int -> String

Line 839:

Line 822:

Or using:

<syntaxhighlight lang=applescript>-- showBin :: Int -> String

<syntaxhighlight lang="applescript">-- showBin :: Int -> String

on showBin(n)

script binaryChar

Line 857:

Line 840:

At its very simplest, an AppleScript solution would look something like this:

<syntaxhighlight lang=applescript>on intToBinary(n)

<syntaxhighlight lang="applescript">on intToBinary(n)

set binary to (n mod 2 div 1) as text

set n to n div 2

Line 875:

Line 858:

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)

<syntaxhighlight lang="applescript">on intToBinary(n)

set binary to ""

repeat

Line 898:

Line 881:

intToBinary(50) & linefeed & ¬

intToBinary(9000) & linefeed</syntaxhighlight>

=={{header|ARM Assembly}}==

/* ARM assembly Raspberry PI */

Line 1,066:

Line 1,048:

</syntaxhighlight>

=={{header|Arturo}}==

<syntaxhighlight lang=rebol>print as.binary 5

<syntaxhighlight lang="rebol">print as.binary 5

print as.binary 50

print as.binary 9000</syntaxhighlight>

Line 1,077:

Line 1,058:

110010

10001100101000</pre>

=={{header|AutoHotkey}}==

<syntaxhighlight lang=~~AutoHotkey~~>MsgBox % NumberToBinary(5) ;101

<syntaxhighlight lang="autohotkey">MsgBox % NumberToBinary(5) ;101

MsgBox % NumberToBinary(50) ;110010

MsgBox % NumberToBinary(9000) ;10001100101000

Line 1,089:

Line 1,069:

Return, Result

}</syntaxhighlight>

=={{header|AutoIt}}==

ConsoleWrite(IntToBin(50) & @CRLF)

Line 1,108:

Line 1,087:

EndFunc ;==>IntToBin

</syntaxhighlight>

=={{header|AWK}}==

<syntaxhighlight lang=awk>BEGIN {

<syntaxhighlight lang="awk">BEGIN {

print tobinary(5)

print tobinary(50)

Line 1,133:

Line 1,111:

return outstr

}</syntaxhighlight>

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

<syntaxhighlight lang=axe>Lbl BIN

<syntaxhighlight lang="axe">Lbl BIN

.Axe supports 16-bit integers, so 16 digits are enough

L₁+16→P

Line 1,147:

Line 1,124:

Disp P,i

Return</syntaxhighlight>

=={{header|BaCon}}==

<syntaxhighlight lang=freebasic>' Binary digits

<syntaxhighlight lang="freebasic">' Binary digits

OPTION MEMTYPE int

INPUT n$

Line 1,157:

Line 1,133:

PRINT CHOP$(BIN$(VAL(n$)), "0", 1)

ENDIF</syntaxhighlight>

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

done

echo "${binary_digits[*]}" | rev

else

echo ERROR : "negative number"

exit 1

fi

}

array=(5 50 9000)

for number in "${array[@]}"; do

echo $number " :> " $(to_binary $number)

done

</syntaxhighlight>

<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

<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$ = ""

Line 1,178:

Line 1,185:

==={{header|BASIC256}}===

# DecToBin.bas

# BASIC256 1.1.4.0

Line 1,198:

Line 1,205:

==={{header|BBC BASIC}}===

<syntaxhighlight lang=bbcbasic> FOR num% = 0 TO 16

<syntaxhighlight lang="bbcbasic"> FOR num% = 0 TO 16

PRINT FN_tobase(num%, 2, 0)

Line 1,216:

Line 1,223:

The above is a generic "Convert to any base" program.

Here is a faster "Convert to Binary" program:

<syntaxhighlight lang=bbcbasic>PRINT FNbinary(5)

<syntaxhighlight lang="bbcbasic">PRINT FNbinary(5)

PRINT FNbinary(50)

PRINT FNbinary(9000)

Line 1,234:

Line 1,241:

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

<syntaxhighlight lang="gwbasic">10 READ N

20 IF N < 0 THEN 70

30 GOSUB 100

Line 1,257:

Line 1,264:

==={{header|IS-BASIC}}===

<syntaxhighlight lang=IS-~~BASIC~~>10 PRINT BIN$(50)

<syntaxhighlight lang="is-basic">10 PRINT BIN$(50)

100 DEF BIN$(N)

110 LET N=ABS(INT(N)):LET B$=""

Line 1,267:

Line 1,274:

==={{header|QBasic}}===

<syntaxhighlight lang=~~QBasic~~>FUNCTION BIN$ (N)

<syntaxhighlight lang="qbasic">FUNCTION BIN$ (N)

N = ABS(INT(N))

B$ = ""

Line 1,285:

Line 1,292:

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:

<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

Line 1,371:

Line 1,378:

==={{header|True BASIC}}===

<syntaxhighlight lang=qbasic>FUNCTION BIN$ (N)

<syntaxhighlight lang="qbasic">FUNCTION BIN$ (N)

LET N = ABS(INT(N))

LET B$ = ""

Line 1,390:

Line 1,397:

PRINT " -> "; BIN$(9000)

END</syntaxhighlight>

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

done

echo "${binary_digits[*]}" | rev

else

echo ERROR : "negative number"

exit 1

fi

}

array=(5 50 9000)

for number in "${array[@]}"; do

echo $number " :> " $(to_binary $number)

done

</syntaxhighlight>

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

<syntaxhighlight lang="dos">@echo off

:num2bin IntVal [RtnVar]

setlocal enableDelayedExpansion

Line 1,440:

Line 1,413:

)

exit /b</syntaxhighlight>

=={{header|bc}}==

<syntaxhighlight lang=bc>obase = 2

<syntaxhighlight lang="bc">obase = 2

5

50

9000

quit</syntaxhighlight>

=={{header|BCPL}}==

<syntaxhighlight lang=bcpl>get "libhdr"

<syntaxhighlight lang="bcpl">get "libhdr"

let writebin(x) be

Line 1,470:

Line 1,441:

110010

10001100101000</pre>

=={{header|Beads}}==

<syntaxhighlight lang=~~Beads~~>beads 1 program 'Binary Digits'

<syntaxhighlight lang="beads">beads 1 program 'Binary Digits'

calc main_init

loop across:[5, 50, 9000] val:v

Line 1,481:

Line 1,451:

10001100101000

</pre>

=={{header|Befunge}}==

Reads the number to convert from standard input.

<pre>9000

10001100101000</pre>

=={{header|BQN}}==

A BQNcrate idiom which returns the digits as a boolean array.

<syntaxhighlight lang=bqn>Bin ← 2{⌽𝕗|⌊∘÷⟜𝕗⍟(↕1+·⌊𝕗⋆⁼1⌈⊢)}

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

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

<syntaxhighlight lang=bracmat> ( dec2bin

<syntaxhighlight lang="bracmat"> ( dec2bin

= bit bits

. :?bits

Line 1,529:

Line 1,496:

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.

<syntaxhighlight lang=bf>+[ Start with n=1 to kick off the loop

<syntaxhighlight lang="bf">+[ Start with n=1 to kick off the loop

[>>++<< Set up {n 0 2} for divmod magic

[->+>- Then

Line 1,551:

Line 1,517:

++++++++++. Print a newline

[-]<+] Zero it then increment n and go again</syntaxhighlight>

=={{header|Burlesque}}==

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

101

Line 1,559:

Line 1,524:

10001100101000

</syntaxhighlight>

=={{header|C}}==

===With bit level operations===

<syntaxhighlight lang=C>#define _CRT_SECURE_NO_WARNINGS // turn off panic warnings

<syntaxhighlight lang="c">#define _CRT_SECURE_NO_WARNINGS // turn off panic warnings

#define _CRT_NONSTDC_NO_DEPRECATE // enable old-gold POSIX names in MSVS

Line 1,682:

Line 1,646:

===With malloc and log10===

Converts int to a string.

<syntaxhighlight lang=c>#include <math.h>

<syntaxhighlight lang="c">#include <math.h>

#include <stdio.h>

#include <stdlib.h>

Line 1,731:

Line 1,695:

10010

10011</pre>

=={{header|C sharp|C#}}==

<syntaxhighlight lang=csharp>using System;

<syntaxhighlight lang="csharp">using System;

class Program

Line 1,745:

Line 1,708:

}

}</syntaxhighlight>

Another version using dotnet 5<syntaxhighlight lang=csharp dotnet 5.0>using System;

Another version using dotnet 5<syntaxhighlight lang="csharp dotnet 5.0">using System;

using System.Text;

Line 1,765:

Line 1,728:

10001100101000

</pre>

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

<syntaxhighlight lang=cpp>#include <bitset>

<syntaxhighlight lang="cpp">#include <bitset>

#include <iostream>

#include <limits>

Line 1,798:

Line 1,760:

</pre>

Shorter version using bitset

<syntaxhighlight lang=cpp>#include <iostream>

<syntaxhighlight lang="cpp">#include <iostream>

#include <bitset>

void printBits(int n) { // Use int like most programming languages.

Line 1,813:

Line 1,775:

} // for testing with n=0 printBits<32>(0);</syntaxhighlight>

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

<syntaxhighlight lang=cpp>#include <iostream>

<syntaxhighlight lang="cpp">#include <iostream>

int main(int argc, char* argv[]) {

unsigned int in[] = {5, 50, 9000}; // Use int like most programming languages

Line 1,823:

Line 1,785:

</syntaxhighlight>

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

<syntaxhighlight lang=cpp>#include <iostream>

<syntaxhighlight lang="cpp">#include <iostream>

int main(int argc, char* argv[]) { // Usage: program.exe 5 50 9000

for (int i = 1; i < argc; i++) // argv[0] is program name

Line 1,832:

Line 1,794:

</syntaxhighlight>

Using bitwise operations with recursion.

#include <iostream>

Line 1,851:

Line 1,813:

10001100101000

</pre>

=={{header|Ceylon}}==

<syntaxhighlight lang=ceylon> shared void run() {

<syntaxhighlight lang="ceylon"> shared void run() {

void printBinary(Integer integer) =>

Line 1,862:

Line 1,823:

printBinary(9k);

}</syntaxhighlight>

=={{header|Clojure}}==

<syntaxhighlight lang=clojure>(Integer/toBinaryString 5)

<syntaxhighlight lang="clojure">(Integer/toBinaryString 5)

(Integer/toBinaryString 50)

(Integer/toBinaryString 9000)</syntaxhighlight>

=={{header|CLU}}==

<syntaxhighlight lang=clu>binary = proc (n: int) returns (string)

<syntaxhighlight lang="clu">binary = proc (n: int) returns (string)

bin: string := ""

while n > 0 do

Line 1,890:

Line 1,849:

50 -> 110010

9000 -> 10001100101000</pre>

=={{header|COBOL}}==

<syntaxhighlight lang=~~COBOL~~> IDENTIFICATION DIVISION.

<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.

PROGRAM-ID. SAMPLE.

Line 1,920:

Line 1,878:

</syntaxhighlight>

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

<syntaxhighlight lang=cobol>IDENTIFICATION DIVISION.

<syntaxhighlight lang="cobol">IDENTIFICATION DIVISION.

PROGRAM-ID. binary-conversion.

Line 1,947:

Line 1,905:

display binary-number.

stop run.</syntaxhighlight>

=={{header|CoffeeScript}}==

<syntaxhighlight lang=coffeescript>binary = (n) ->

<syntaxhighlight lang="coffeescript">binary = (n) ->

new Number(n).toString(2)

console.log binary n for n in [5, 50, 9000]</syntaxhighlight>

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

Just print the number with "~b":

<syntaxhighlight lang=lisp>(format t "~b" 5)

<syntaxhighlight lang="lisp">(format t "~b" 5)

; or

(write 5 :base 2)</syntaxhighlight>

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE BinaryDigits;

IMPORT StdLog,Strings;

Line 1,987:

Line 1,942:

50:> 110010

9000:> 10001100101000</pre>

=={{header|Cowgol}}==

<syntaxhighlight lang=cowgol>include "cowgol.coh";

<syntaxhighlight lang="cowgol">include "cowgol.coh";

sub print_binary(n: uint32) is

Line 2,013:

Line 1,967:

110010

10001100101000</pre>

=={{header|Crystal}}==

Using an array

<syntaxhighlight lang=ruby>[5,50,9000].each do |n|

<syntaxhighlight lang="ruby">[5,50,9000].each do |n|

puts "%b" % n

end</syntaxhighlight>

Using a tuple

<pre>101

110010

10001100101000</pre>

=={{header|D}}==

<syntaxhighlight lang=d>void main() {

<syntaxhighlight lang="d">void main() {

import std.stdio;

Line 2,051:

Line 2,003:

1110

1111</pre>

=={{header|Dart}}==

<syntaxhighlight lang=dart>String binary(int n) {

<syntaxhighlight lang="dart">String binary(int n) {

if(n<0)

throw new IllegalArgumentException("negative numbers require 2s complement");

Line 2,078:

Line 2,029:

print(binary(0x123456789abcdef));

}</syntaxhighlight>

=={{header|dc}}==

Line 2,086:

Line 2,036:

110010

10001100101000</pre>

=={{header|Delphi}}==

program BinaryDigit;

{$APPTYPE CONSOLE}

Line 2,114:

Line 2,063:

9000: 10001100101000

</pre>

=={{header|Dyalect}}==

A default <code>ToString</code> method of type <code>Integer</code> is overriden and returns a binary representation of a number:

<syntaxhighlight lang=dyalect>func Integer.ToString() {

<syntaxhighlight lang="dyalect">func Integer.ToString() {

var s = ""

for x in 31^-1..0 {

Line 2,136:

Line 2,084:

=={{header|EasyLang}}==

<syntaxhighlight lang=text>func to2 n . r$ .

<syntaxhighlight lang="text">func to2 n . r$ .

if n > 0

call to2 n div 2 r$

Line 2,168:

Line 2,115:

10001100101000

</pre>

=={{header|EchoLisp}}==

;; primitive : (number->string number [base]) - default base = 10

Line 2,181:

Line 2,127:

10001100101000

</syntaxhighlight>

=={{header|Elena}}==

ELENA 5.0 :

<syntaxhighlight lang=elena>import system'routines;

<syntaxhighlight lang="elena">import system'routines;

import extensions;

Line 2,200:

Line 2,145:

10001100101000

</pre>

=={{header|Elixir}}==

Use <code>Integer.to_string</code> with a base of 2:

IO.puts Integer.to_string(5,2)

</syntaxhighlight>

Or, using the pipe operator:

5 |> Integer.to_string(2) |> IO.puts

</syntaxhighlight>

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

</syntaxhighlight>

Line 2,220:

Line 2,164:

10001100101000

</pre>

=={{header|Epoxy}}==

<syntaxhighlight lang=epoxy>fn bin(a,b:true)

<syntaxhighlight lang="epoxy">fn bin(a,b:true)

var c:""

while a>0 do

Line 2,244:

Line 2,187:

9000: 10001100101000

</pre>

=={{header|Erlang}}==

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

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

<pre>101

110010

10001100101000</pre>

=={{header|Euphoria}}==

<syntaxhighlight lang=euphoria>function toBinary(integer i)

<syntaxhighlight lang="euphoria">function toBinary(integer i)

sequence s

s = {}

Line 2,268:

Line 2,209:

=== Functional/Recursive ===

<syntaxhighlight lang=euphoria>include std/math.e

<syntaxhighlight lang="euphoria">include std/math.e

include std/convert.e

Line 2,284:

Line 2,225:

printf(1, "%d\n", Bin(50))

printf(1, "%d\n", Bin(9000))</syntaxhighlight>

=={{header|F Sharp|F#}}==

By translating C#'s approach, using imperative coding style (inflexible):

<syntaxhighlight lang=~~FSharp~~>open System

<syntaxhighlight lang="fsharp">open System

for i in [5; 50; 9000] do printfn "%s" <| Convert.ToString (i, 2)</syntaxhighlight>

Alternatively, by creating a function <code>printBin</code> which prints in binary (more flexible):

<syntaxhighlight lang=~~FSharp~~>open System

<syntaxhighlight lang="fsharp">open System

// define the function

Line 2,304:

Line 2,244:

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

<syntaxhighlight lang="fsharp">open System

open System.IO

Line 2,320:

Line 2,260:

10001100101000

</pre>

=={{header|Factor}}==

<syntaxhighlight lang=factor>USING: io kernel math math.parser ;

<syntaxhighlight lang="factor">USING: io kernel math math.parser ;

5 >bin print

50 >bin print

9000 >bin print</syntaxhighlight>

=={{header|FALSE}}==

<syntaxhighlight lang=false>[0\10\[$1&'0+\2/$][]#%[$][,]#%]b:

<syntaxhighlight lang="false">[0\10\[$1&'0+\2/$][]#%[$][,]#%]b:

5 b;!

Line 2,338:

Line 2,276:

110010

10001100101000</pre>

=={{header|FBSL}}==

<syntaxhighlight lang=fbsl>#AppType Console

<syntaxhighlight lang="fbsl">#AppType Console

function Bin(byval n as integer, byval s as string = "") as string

if n > 0 then return Bin(n \ 2, (n mod 2) & s)

Line 2,353:

Line 2,290:

pause

</syntaxhighlight>

=={{header|FOCAL}}==

<syntaxhighlight lang=~~FOCAL~~>01.10 S A=5;D 2

<syntaxhighlight lang="focal">01.10 S A=5;D 2

01.20 S A=50;D 2

01.30 S A=9000;D 2

Line 2,374:

Line 2,310:

110010

10001100101000</pre>

=={{header|Forth}}==

<syntaxhighlight lang=forth>\ Forth uses a system variable 'BASE' for number conversion

<syntaxhighlight lang="forth">\ Forth uses a system variable 'BASE' for number conversion

\ HEX is a standard word to change the value of base to 16

Line 2,404:

Line 2,339:

110000

</pre>

=={{header|Fortran}}==

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

!-*- mode: compilation; default-directory: "/tmp/" -*-

!Compilation started at Sun May 19 23:14:14

Line 2,466:

Line 2,400:

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

<syntaxhighlight lang="pascal">program binaryDigits(input, output, stdErr);

{$mode ISO}

Line 2,494:

Line 2,427:

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 2,514:

Line 2,446:

9000 -> 10001100101000

</pre>

=={{header|Frink}}==

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

9000 -> binary

9000 -> base2

Line 2,523:

Line 2,454:

base[9000, 2]

</syntaxhighlight>

=={{header|FunL}}==

<syntaxhighlight lang=funl>for n <- [5, 50, 9000, 9000000000]

<syntaxhighlight lang="funl">for n <- [5, 50, 9000, 9000000000]

println( n, bin(n) )</syntaxhighlight>

Line 2,536:

Line 2,466:

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.

fun main(x: i32): i64 =

loop (out = 0i64) = for i < 32 do

Line 2,549:

Line 2,478:

in out

</syntaxhighlight>

=={{header|FutureBasic}}==

The decimal to binary conversion can be handled with a simple function.

include "NSLog.incl"

Line 2,577:

Line 2,504:

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

<syntaxhighlight lang="gambas">Public Sub Main()

Dim siBin As Short[] = [5, 50, 9000]

Dim siCount As Short

Line 2,596:

Line 2,521:

10001100101000

</pre>

=={{header|Go}}==

<syntaxhighlight lang=go>package main

<syntaxhighlight lang="go">package main

import (

Line 2,628:

Line 2,552:

1111

</pre>

=={{header|Groovy}}==

Solutions:

<syntaxhighlight lang=groovy>print '''

<syntaxhighlight lang="groovy">print '''

n binary

----- ---------------

Line 2,644:

Line 2,567:

50 110010

9000 10001100101000</pre>

=={{header|Haskell}}==

<syntaxhighlight lang=haskell>import Data.List

<syntaxhighlight lang="haskell">import Data.List

import Numeric

import Text.Printf

Line 2,681:

Line 2,603:

and in terms of first and swap, we could also write this as:

<syntaxhighlight lang=haskell>import Data.Bifunctor (first)

<syntaxhighlight lang="haskell">import Data.Bifunctor (first)

import Data.List (unfoldr)

import Data.Tuple (swap)

Line 2,708:

Line 2,630:

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.

<syntaxhighlight lang=~~Icon~~>procedure main()

<syntaxhighlight lang="icon">procedure main()

every i := 5 | 50 | 255 | 1285 | 9000 do

write(i," = ",binary(i))

Line 2,740:

Line 2,661:

1285 = 10100000101

9000 = 10001100101000</pre>

=={{header|Idris}}==

<syntaxhighlight lang=~~Idris~~>module Main

<syntaxhighlight lang="idris">module Main

binaryDigit : Integer -> Char

Line 2,768:

Line 2,688:

10001100101000

</pre>

=={{header|J}}==

<syntaxhighlight lang=j> tobin=: -.&' '@":@#:

<syntaxhighlight lang="j"> tobin=: -.&' '@":@#:

tobin 5

101

Line 2,780:

Line 2,699:

I am using implicit output.

=={{header|Java}}==

<syntaxhighlight lang=java>public class Main {

<syntaxhighlight lang="java">public class Main {

public static void main(String[] args) {

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

Line 2,793:

Line 2,711:

110010

10001100101000</pre>

=={{header|JavaScript}}==

===ES5===

<syntaxhighlight lang=javascript>function toBinary(number) {

<syntaxhighlight lang="javascript">function toBinary(number) {

return new Number(number)

.toString(2);

Line 2,809:

Line 2,726:

The simplest showBinary (or showIntAtBase), using default digit characters, would use JavaScript's standard String.toString(base):

<syntaxhighlight lang=~~JavaScript~~>(() => {

<syntaxhighlight lang="javascript">(() => {

"use strict";

Line 2,840:

Line 2,757:

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~~>(() => {

<syntaxhighlight lang="javascript">(() => {

"use strict";

Line 2,900:

Line 2,817:

50 -> 一一〇〇一〇

9000 -> 一〇〇〇一一〇〇一〇一〇〇〇</pre>

=={{header|Joy}}==

<syntaxhighlight lang=joy>HIDE

<syntaxhighlight lang="joy">HIDE

_ == [null] [pop] [2 div swap] [48 + putch] linrec

IN

Line 2,908:

Line 2,824:

END</syntaxhighlight>

Using int2bin:

<syntaxhighlight lang=joy>0 setautoput

<syntaxhighlight lang="joy">0 setautoput

0 int2bin

5 int2bin

50 int2bin

9000 int2bin.</syntaxhighlight>

=={{header|jq}}==

<syntaxhighlight lang=jq>def binary_digits:

<syntaxhighlight lang="jq">def binary_digits:

[ recurse( ./2 | floor; . > 0) % 2 ] | reverse | join("") ;

Line 2,925:

Line 2,840:

110010

10001100101000

=={{header|Julia}}==

<syntaxhighlight lang=julia>using Printf

<syntaxhighlight lang="julia">using Printf

for n in (0, 5, 50, 9000)

Line 2,952:

Line 2,866:

50 → 00000000000000110010

9000 → 00000010001100101000</pre>

=={{header|K}}==

<syntaxhighlight lang=k> tobin: ,/$2_vs

<syntaxhighlight lang="k"> tobin: ,/$2_vs

tobin' 5 50 9000

("101"

"110010"

"10001100101000")</syntaxhighlight>

=={{header|Kotlin}}==

<syntaxhighlight lang=scala>// version 1.0.5-2

<syntaxhighlight lang="scala">// version 1.0.5-2

fun main(args: Array<String>) {

Line 2,974:

Line 2,886:

9000 -> 10001100101000

</pre>

=={{header|Lambdatalk}}==

{def dec2bin

{lambda {:dec}

Line 3,000:

Line 2,911:

</syntaxhighlight>

=={{header|Lang5}}==

<syntaxhighlight lang=lang5>'%b '__number_format set

<syntaxhighlight lang="lang5">'%b '__number_format set

[5 50 9000] [3 1] reshape .</syntaxhighlight>

Line 3,010:

Line 2,920:

[ 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 3,033:

Line 2,942:

10001100101000

</pre>

=={{header|Liberty BASIC}}==

<syntaxhighlight lang=lb>for a = 0 to 16

<syntaxhighlight lang="lb">for a = 0 to 16

print a;"=";dec2bin$(a)

Line 3,051:

Line 2,959:

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.

// Little Man Computer, for Rosetta Code.

// Read numbers from user and display them in binary.

Line 3,123:

Line 3,030:

900->1110000100

</pre>

=={{header|LLVM}}==

<syntaxhighlight lang=llvm>; ModuleID = 'binary.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"

Line 3,328:

Line 3,233:

10010

10011</pre>

=={{header|Locomotive Basic}}==

<syntaxhighlight lang=locobasic>10 PRINT BIN$(5)

<syntaxhighlight lang="locobasic">10 PRINT BIN$(5)

20 PRINT BIN$(50)

30 PRINT BIN$(9000)</syntaxhighlight>

Line 3,337:

Line 3,241:

110010

10001100101000</pre>

=={{header|LOLCODE}}==

<syntaxhighlight lang=~~LOLCODE~~>HAI 1.3

<syntaxhighlight lang="lolcode">HAI 1.3

HOW IZ I DECIMULBINUR YR DECIMUL

I HAS A BINUR ITZ ""

Line 3,360:

Line 3,263:

110010

10001100101000</pre>

=={{header|Lua}}==

===Lua - Iterative===

<syntaxhighlight lang=~~Lua~~>function dec2bin (n)

<syntaxhighlight lang="lua">function dec2bin (n)

local bin = ""

while n > 0 do

Line 3,381:

Line 3,283:

===Lua - Recursive===

<syntaxhighlight lang=lua>function dec2bin(n, bin)

<syntaxhighlight lang="lua">function dec2bin(n, bin)

bin = (n&1) .. (bin or "") -- use n%2 instead of n&1 for Lua 5.1/5.2

return n>1 and dec2bin(n//2, bin) or bin -- use math.floor(n/2) instead of n//2 for Lua 5.1/5.2

Line 3,393:

Line 3,295:

110010

10001100101000</pre>

=={{header|M2000 Interpreter}}==

Module Checkit {

Form 90, 40

Line 3,463:

Line 3,364:

</pre >

=={{header|MAD}}==

MAD has basically no support for runtime generation of strings.

Line 3,469:

Line 3,369:

matches the binary representation of the input, e.g. <code>BINARY.(5)</code> is <code>101</code>.

<syntaxhighlight lang=~~MAD~~> NORMAL MODE IS INTEGER

<syntaxhighlight lang="mad"> NORMAL MODE IS INTEGER

INTERNAL FUNCTION(NUM)

Line 3,494:

Line 3,394:

50: 110010

9000: 10001100101000</pre>

=={{header|Maple}}==

> convert( 50, 'binary' );

110010

Line 3,502:

Line 3,401:

10001100101000

</syntaxhighlight>

=={{header|Mathematica}} / {{header|Wolfram Language}}==

<syntaxhighlight lang=~~Mathematica~~>StringJoin @@ ToString /@ IntegerDigits[50, 2] </syntaxhighlight>

<syntaxhighlight lang="mathematica">StringJoin @@ ToString /@ IntegerDigits[50, 2] </syntaxhighlight>

=={{header|MATLAB}} / {{header|Octave}}==

<syntaxhighlight lang=~~Matlab~~> dec2bin(5)

<syntaxhighlight lang="matlab"> dec2bin(5)

dec2bin(50)

dec2bin(9000) </syntaxhighlight>

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

=={{header|Maxima}}==

<syntaxhighlight lang=maxima>digits([arg]) := block(

<syntaxhighlight lang="maxima">digits([arg]) := block(

[n: first(arg), b: if length(arg) > 1 then second(arg) else 10, v: [ ], q],

do (

Line 3,525:

Line 3,421:

10001100101000

*/</syntaxhighlight>

=={{header|MAXScript}}==

-- MAXScript: Output decimal numbers from 0 to 16 as Binary : N.H. 2019

for k = 0 to 16 do

Line 3,572:

Line 3,467:

"10000"

</pre>

=={{header|Mercury}}==

<syntaxhighlight lang=mercury>:- module binary_digits.

<syntaxhighlight lang="mercury">:- module binary_digits.

:- interface.

Line 3,591:

Line 3,485:

io.write_string(int_to_base_string(N, 2), !IO),

io.nl(!IO).</syntaxhighlight>

=={{header|min}}==

<syntaxhighlight lang=min>(2 over over mod 'div dip) :divmod2

<syntaxhighlight lang="min">(2 over over mod 'div dip) :divmod2

(

Line 3,610:

Line 3,503:

10001100101000

</pre>

=={{header|MiniScript}}==

=== Iterative ===

<syntaxhighlight lang=~~MiniScript~~>binary = function(n)

<syntaxhighlight lang="miniscript">binary = function(n)

result = ""

while n

Line 3,629:

Line 3,521:

=== Recursive ===

<syntaxhighlight lang=~~MiniScript~~>binary = function(n,result="")

<syntaxhighlight lang="miniscript">binary = function(n,result="")

if n == 0 then

if result == "" then return "0" else return result

Line 3,648:

Line 3,540:

0

</pre>

=={{header|mLite}}==

<syntaxhighlight lang=sml>fun binary

<syntaxhighlight lang="sml">fun binary

(0, b) = implode ` map (fn x = if int x then chr (x + 48) else x) b

| (n, b) = binary (n div 2, n mod 2 :: b)

Line 3,665:

Line 3,556:

> binary 9000;

"10001100101000"</pre>

=={{header|Modula-2}}==

<syntaxhighlight lang=modula2>MODULE Binary;

<syntaxhighlight lang="modula2">MODULE Binary;

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT Write,WriteLn,ReadChar;

Line 3,696:

Line 3,586:

ReadChar

END Binary.</syntaxhighlight>

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

<syntaxhighlight lang=modula3>MODULE Binary EXPORTS Main;

<syntaxhighlight lang="modula3">MODULE Binary EXPORTS Main;

IMPORT IO, Fmt;

Line 3,714:

Line 3,603:

10010110

</pre>

=={{header|NetRexx}}==

<syntaxhighlight lang=~~NetRexx~~>/* NetRexx */

<syntaxhighlight lang="netrexx">/* NetRexx */

options replace format comments java crossref symbols nobinary

Line 3,741:

Line 3,629:

9000: 10001100101000

</pre>

=={{header|NewLisp}}==

;;; Using the built-in "bits" function

;;; For integers up to 9,223,372,036,854,775,807

Line 3,766:

Line 3,653:

1110100000110010010010000001110101110000001101101111110011101110001010110010111100010111111001011011001110001111110000101011010010

</pre>

=={{header|Nickle}}==

Using the Nickle output radix operator:

Line 3,779:

Line 3,665:

> 9000 # 2

10001100101000</pre>

=={{header|Nim}}==

<syntaxhighlight lang=nim>proc binDigits(x: BiggestInt, r: int): int =

<syntaxhighlight lang="nim">proc binDigits(x: BiggestInt, r: int): int =

## Calculates how many digits `x` has when each digit covers `r` bits.

result = 1

Line 3,824:

Line 3,709:

===Version using strformat===

<syntaxhighlight lang=~~Nim~~>import strformat

<syntaxhighlight lang="nim">import strformat

for n in 0..15:

Line 3,846:

Line 3,731:

1110

1111</pre>

=={{header|Oberon-2}}==

MODULE BinaryDigits;

IMPORT Out;

Line 3,876:

Line 3,760:

101010

</pre>

=={{header|Objeck}}==

<syntaxhighlight lang=objeck>class Binary {

<syntaxhighlight lang="objeck">class Binary {

function : Main(args : String[]) ~ Nil {

5->ToBinaryString()->PrintLine();

Line 3,891:

Line 3,774:

10001100101000

</pre>

=={{header|OCaml}}==

<syntaxhighlight lang=ocaml>let bin_of_int d =

<syntaxhighlight lang="ocaml">let bin_of_int d =

if d < 0 then invalid_arg "bin_of_int" else

if d = 0 then "0" else

Line 3,905:

Line 3,787:

let d = read_int () in

Printf.printf "%8s\n" (bin_of_int d)</syntaxhighlight>

=={{header|Oforth}}==

Line 3,923:

Line 3,804:

ok

</pre>

=={{header|Ol}}==

(print (number->string 5 2))

(print (number->string 50 2))

Line 3,936:

Line 3,816:

10001100101000

</pre>

=={{header|OxygenBasic}}==

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

function BinaryBits(sys n) as string

Line 3,984:

Line 3,863:

print BinaryBits 0xaa 'result 10101010

</syntaxhighlight>

=={{header|Panda}}==

<syntaxhighlight lang=panda>0..15.radix:2 nl</syntaxhighlight>

<syntaxhighlight lang="panda">0..15.radix:2 nl</syntaxhighlight>

<pre>0

Line 4,004:

Line 3,882:

1110

1111</pre>

=={{header|PARI/GP}}==

<syntaxhighlight lang=parigp>bin(n:int)=concat(apply(s->Str(s),binary(n)))</syntaxhighlight>

<syntaxhighlight lang="parigp">bin(n:int)=concat(apply(s->Str(s),binary(n)))</syntaxhighlight>

=={{header|Pascal}}==

FPC compiler Version 2.6 upwards.The obvious version.

<syntaxhighlight lang=pascal>program IntToBinTest;

<syntaxhighlight lang="pascal">program IntToBinTest;

{$MODE objFPC}

uses

Line 4,051:

Line 3,927:

Beware of the endianess of the constant.

I check performance with random Data.

program IntToPcharTest;

uses

Line 4,171:

Line 4,047:

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|Peloton}}==

<@ saybaslit>0</@>

Line 4,180:

Line 4,055:

<@ saybaslit>9000</@>

</syntaxhighlight>

=={{header|Perl}}==

<syntaxhighlight lang=perl>for (5, 50, 9000) {

<syntaxhighlight lang="perl">for (5, 50, 9000) {

printf "%b\n", $_;

}</syntaxhighlight>

Line 4,190:

Line 4,064:

10001100101000

</pre>

=={{header|Phix}}==

printf(1,"%b\n",5)

printf(1,"%b\n",50)

Line 4,203:

Line 4,076:

10001100101000

</pre>

=={{header|Phixmonti}}==

<syntaxhighlight lang=~~Phixmonti~~>def printBinary

<syntaxhighlight lang="phixmonti">def printBinary

"The decimal value " print dup print " should produce an output of " print

20 int>bit

Line 4,230:

Line 4,102: