Binary digits: Difference between revisions

[[Category:Radices]]

 

;Task:

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>

{{out}}

110010

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

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

{{out}}

9000 = 10001100101000

</pre>

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

BINARY CSECT

USING BINARY,R12

9000 10001100101000

</pre>

 

=={{header|6502 Assembly}}==

{{works with|http://vice-emu.sourceforge.net/ VICE}}

strout = $cb1e

</pre>

; C64 - Binary digits

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

100

</pre>

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

puts: equ 9h ; Print string

org 100h

 

</pre>

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

.stack 1024

.data

ret

PrintBinary_NoLeadingZeroes endp</syntaxhighlight>

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

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program binarydigit.s */

The decimal value +1 should produce an output of 1

</pre>

=={{header|ACL2}}==

 

(defun bin-string-r (x)

"0"

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

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

CHAR ARRAY a(16)

BYTE i=[0]

Output for 9000 is 10001100101000

</pre>

=={{header|Ada}}==

 

procedure binary is

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

Output for 9000 is 10001100101000

</pre>

=={{header|Aime}}==

o_byte('\n');

o_xinteger(2, 5);

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

 

printf((

+9000 => TFFFTTFFTFTFFF

</pre>

 

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

procedure writebin(n);

integer n;

110010

10001100101000</pre>

=={{header|APL}}==

Works in: [[Dyalog APL]]

 

A builtin function. Produces a boolean array.

 

 

 

Produces a boolean array.

 

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

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

</pre>

=={{header|AppleScript}}==

===Functional===

 

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

 

-- showBin :: Int -> String

 

Or using:

on showBin(n)

script binaryChar

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

 

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

set n to n div 2

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:

 

set binary to ""

repeat

intToBinary(50) & linefeed & ¬

intToBinary(9000) & linefeed</syntaxhighlight>

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

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

 

</syntaxhighlight>

=={{header|Arturo}}==

print as.binary 50

print as.binary 9000</syntaxhighlight>

110010

10001100101000</pre>

=={{header|AutoHotkey}}==

MsgBox % NumberToBinary(50) ;110010

MsgBox % NumberToBinary(9000) ;10001100101000

Return, Result

}</syntaxhighlight>

=={{header|AutoIt}}==

ConsoleWrite(IntToBin(50) & @CRLF)

 

 

=={{header|AWK}}==

print tobinary(5)

print tobinary(50)

 

function tobinary(num) {

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.

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

L₁+16→P

Disp P,i

Return</syntaxhighlight>

=={{header|BaCon}}==

OPTION MEMTYPE int

INPUT n$

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

ENDIF</syntaxhighlight>

 

=={{header|BASIC}}==

 

==={{header|Applesoft BASIC}}===

1 LET N2 = ABS ( INT (N))

2 LET B$ = ""

 

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

# DecToBin.bas

# BASIC256 1.1.4.0

 

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

PRINT FN_tobase(num%, 2, 0)

NEXT

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

Here is a faster "Convert to Binary" program:

PRINT FNbinary(50)

PRINT FNbinary(9000)

UNTIL N% = 0

=A$</syntaxhighlight>

 

==={{header|Commodore BASIC}}===

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.

 

20 IF N < 0 THEN 70

30 GOSUB 100

 

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

100 DEF BIN$(N)

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

 

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

N = ABS(INT(N))

B$ = ""

 

This turns into a horrible mess because of the lack of string concatenation in print statements, and the necessity of suppressing leading zeroes.

REM A-O: binary digits with A least significant and N most significant

REM X: number whose binary expansion we want

 

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

LET N = ABS(INT(N))

LET B$ = ""

END</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.

:num2bin IntVal [RtnVar]

setlocal enableDelayedExpansion

)

exit /b</syntaxhighlight>

=={{header|bc}}==

{{trans|dc}}

5

50

9000

quit</syntaxhighlight>

=={{header|BCPL}}==

 

let writebin(x) be

110010

10001100101000</pre>

=={{header|Beads}}==

calc main_init

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

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.

 

=={{header|Bracmat}}==

= bit bits

. :?bits

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

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

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

=={{header|Burlesque}}==

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

101

10001100101000

</syntaxhighlight>

=={{header|C}}==

===With bit level operations===

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

 

===With malloc and log10===

Converts int to a string.

#include <stdio.h>

#include <stdlib.h>

10010

10011</pre>

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

 

class Program

}

}</syntaxhighlight>

using System.Text;

 

10001100101000

</pre>

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

#include <iostream>

#include <limits>

</pre>

Shorter version using bitset

#include <bitset>

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

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

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

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

</syntaxhighlight>

Using bitwise operations with recursion.

#include <iostream>

 

10001100101000

</pre>

=={{header|Ceylon}}==

void printBinary(Integer integer) =>

printBinary(9k);

}</syntaxhighlight>

=={{header|Clojure}}==

(Integer/toBinaryString 50)

(Integer/toBinaryString 9000)</syntaxhighlight>

=={{header|CLU}}==

bin: string := ""

while n > 0 do

50 -> 110010

9000 -> 10001100101000</pre>

=={{header|COBOL}}==

PROGRAM-ID. SAMPLE.

 

</syntaxhighlight>

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

PROGRAM-ID. binary-conversion.

 

display binary-number.

stop run.</syntaxhighlight>

=={{header|CoffeeScript}}==

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

 

; or

 

(write 5 :base 2)</syntaxhighlight>

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

BlackBox Component Builder

MODULE BinaryDigits;

IMPORT StdLog,Strings;

50:> 110010

9000:> 10001100101000</pre>

=={{header|Cowgol}}==

 

sub print_binary(n: uint32) is

110010

10001100101000</pre>

=={{header|Crystal}}==

{{trans|Ruby}}

Using an array

puts "%b" % n

end</syntaxhighlight>

Using a tuple

{{out}}

<pre>101

110010

10001100101000</pre>

=={{header|D}}==

import std.stdio;

 

1110

1111</pre>

=={{header|Dart}}==

if(n<0)

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

print(binary(0x123456789abcdef));

}</syntaxhighlight>

=={{header|dc}}==

 

{{out}}

110010

10001100101000</pre>

=={{header|Delphi}}==

program BinaryDigit;

{$APPTYPE CONSOLE}

9000: 10001100101000

</pre>

 

=={{header|Dyalect}}==

 

 

var s = ""

for x in 31^-1..0 {

print("5 == \(5), 50 = \(50), 1000 = \(9000)")</syntaxhighlight>

{{out}}

<pre>5 == 101, 50 = 110010, 1000 = 10001100101000</pre>

 

=={{header|EasyLang}}==

.

<pre>

101

 

=={{header|EchoLisp}}==

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

 

10001100101000

</syntaxhighlight>

 

=={{header|Elena}}==

import extensions;

 

public program()

{

{

console.printLine(n.toString(2))

=={{header|Elixir}}==

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

</syntaxhighlight>

Or, using the pipe operator:

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

</syntaxhighlight>

</syntaxhighlight>

 

110010

10001100101000

</pre>

 

=={{header|Epoxy}}==

var c:""

while a>0 do

9000: 10001100101000

</pre>

=={{header|Erlang}}==

{{out}}

<pre>101

 

=={{header|Euphoria}}==

sequence s

s = {}

 

=== Functional/Recursive ===

include std/convert.e

 

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

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

 

// define the function

Or more idiomatic so that you can use it with any printf-style function and the <code>%a</code> format specifier (most flexible):

 

open System.IO

 

10001100101000

</pre>

=={{header|Factor}}==

 

5 >bin print

50 >bin print

9000 >bin print</syntaxhighlight>

=={{header|FALSE}}==

 

5 b;!

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)

pause

</syntaxhighlight>

=={{header|FOCAL}}==

01.20 S A=50;D 2

01.30 S A=9000;D 2

110010

10001100101000</pre>

=={{header|Forth}}==

 

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

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

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.

{$mode ISO}

 

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 = "#### -> &"

9000 -> 10001100101000

</pre>

=={{header|Frink}}==

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

9000 -> binary

9000 -> base2

base[9000, 2]

</syntaxhighlight>

=={{header|FunL}}==

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

 

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

in out

</syntaxhighlight>

=={{header|FutureBasic}}==

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

include "NSLog.incl"

 

9000 = 10001100101000

</pre>

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=03e84768e6ee2af9b7664efa04fa6da8 Click this link to run this code]'''

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

Dim siCount As Short

10001100101000

</pre>

=={{header|Go}}==

 

import (

1111

</pre>

=={{header|Groovy}}==

Solutions:

n binary

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

50 110010

9000 10001100101000</pre>

=={{header|Haskell}}==

import Numeric

import Text.Printf

 

-- Use the built-in function showIntAtBase.

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

 

import Data.List (unfoldr)

import Data.Tuple (swap)

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

1285 = 10100000101

9000 = 10001100101000</pre>

=={{header|Idris}}==

 

binaryDigit : Integer -> Char

10001100101000

</pre>

=={{header|J}}==

tobin 5

101

tobin 9000

10001100101000</syntaxhighlight>

 

=={{header|Java}}==

110010

 

=={{header|JavaScript}}==

===ES5===

return new Number(number)

.toString(2);

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

 

"use strict";

 

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:

 

"use strict";

 

50 -> 一一〇〇一〇

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

=={{header|Joy}}==

 

=={{header|jq}}==

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

 

110010

10001100101000

=={{header|Julia}}==

{{works with|Julia|1.0}}

 

 

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

50 → 00000000000000110010

9000 → 00000010001100101000</pre>

=={{header|K}}==

tobin' 5 50 9000

("101"

"110010"

"10001100101000")</syntaxhighlight>

=={{header|Kotlin}}==

val numbers = intArrayOf(5, 50, 9000)

}</syntaxhighlight>

 

{{out}}

<pre>

9000 -> 10001100101000

</pre>

 

=={{header|Lambdatalk}}==

{def dec2bin

{lambda {:dec}

50 -> 110010

9000 -> 10001100101000

 

</syntaxhighlight>

 

=={{header|Lang5}}==

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

{{out}}

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

10001100101000

</pre>

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

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

next

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.

900->1110000100

</pre>

=={{header|LLVM}}==

{{trans|C}}

; source_filename = "binary.c"

; target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"

10010

10011</pre>

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

20 PRINT BIN$(50)

30 PRINT BIN$(9000)</syntaxhighlight>

110010

10001100101000</pre>

=={{header|LOLCODE}}==

HOW IZ I DECIMULBINUR YR DECIMUL

I HAS A BINUR ITZ ""

=={{header|Lua}}==

===Lua - Iterative===

local bin = ""

bin = n % 2 .. bin

n = math.floor(n / 2)

end

end

 

110010

10001100101000</pre>

===Lua - Recursive===

{{works with|Lua|5.3+}}

end

 

 

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

Module Checkit {

Form 90, 40

 

</pre >

 

=={{header|MAD}}==

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

 

INTERNAL FUNCTION(NUM)

 

=={{header|Maple}}==

> convert( 50, 'binary' );

110010

10001100101000

</syntaxhighlight>

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

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

dec2bin(50)

dec2bin(9000) </syntaxhighlight>

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 (

10001100101000

*/</syntaxhighlight>

=={{header|MAXScript}}==

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

for k = 0 to 16 do

"10000"

</pre>

=={{header|Mercury}}==

:- interface.

 

 

=={{header|min}}==

 

{{out}}

 

=={{header|MiniScript}}==

=== Iterative ===

result = ""

while n

 

=== Recursive ===

if n == 0 then

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

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)

> binary 9000;

"10001100101000"</pre>

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

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT Write,WriteLn,ReadChar;

ReadChar

END Binary.</syntaxhighlight>

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

 

IMPORT IO, Fmt;

10010110

</pre>

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

9000: 10001100101000

</pre>

=={{header|NewLisp}}==

 

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

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

1110100000110010010010000001110101110000001101101111110011101110001010110010111100010111111001011011001110001111110000101011010010

</pre>

=={{header|Nickle}}==

Using the Nickle output radix operator:

> 9000 # 2

10001100101000</pre>

=={{header|Nim}}==

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

result = 1

 

===Version using strformat===

 

for n in 0..15:

1110

1111</pre>

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

MODULE BinaryDigits;

IMPORT Out;

101010

</pre>

=={{header|Objeck}}==

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

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

10001100101000

</pre>

=={{header|OCaml}}==

in

 

=={{header|Oforth}}==

ok

</pre>

=={{header|Ol}}==

(print (number->string 5 2))

(print (number->string 50 2))

10001100101000

</pre>

=={{header|OxygenBasic}}==

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

 

function BinaryBits(sys n) as string

print BinaryBits 0xaa 'result 10101010

</syntaxhighlight>

=={{header|Panda}}==

{{out}}

<pre>0

1110

1111</pre>

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

=={{header|Pascal}}==

{{works with|Free Pascal}}

FPC compiler Version 2.6 upwards.The obvious version.

{$MODE objFPC}

uses

Beware of the endianess of the constant.

I check performance with random Data.

program IntToPcharTest;

uses

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

<@ saybaslit>9000</@>

</syntaxhighlight>

=={{header|Perl}}==

printf "%b\n", $_;

}</syntaxhighlight>

10001100101000

</pre>

=={{header|Phix}}==

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

10001100101000

</pre>

=={{header|Phixmonti}}==

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

20 int>bit

 

Other solution

by Galileo, 05/2022 #/

 

 

=== Press any key to exit ===</pre>

=={{header|PHP}}==

echo decbin(5);

echo decbin(50);

110010

10001100101000</pre>

=={{header|Picat}}==

println(to_binary_string(I))

end.</syntaxhighlight>

110010

1110000100</pre>

=={{header|PicoLisp}}==

-> "101"

 

: (bin 9000)

-> "10001100101000"</syntaxhighlight>

=={{header|Piet}}==

 

 

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

1111111111111111111111111111111

</pre>

=={{header|PL/M}}==

 

/* CP/M BDOS CALL */

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.

#COMPILE EXE

#DIM ALL

9000: 10001100101000 (00000000000000000010001100101000)

</pre>

=={{header|PowerShell}}==

{{libheader|Microsoft .NET Framework}}

{{out}}

<pre>101

110010

1110000100</pre>

=={{header|Processing}}==

println(Integer.toBinaryString(50)); // 110010

println(Integer.toBinaryString(9000)); // 10001100101000</syntaxhighlight>

Processing also has a binary() function, but this returns zero-padded results

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.

110010

10001100101000</pre>

=={{header|PureBasic}}==

PrintN(Bin(5)) ;101

PrintN(Bin(50)) ;110010

110010

10001100101000</pre>

=={{header|Python}}==

===String.format() method===

{{works with|Python|3.X and 2.6+}}

 

0

===Built-in bin() function===

{{works with|Python|3.X and 2.6+}}

 

0

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

 

Defined in terms of a more general '''showIntAtBase''' function:

 

 

 

Or, using a more specialised function to decompose an integer to a list of boolean values:

 

 

50 -> 110010

9000 -> 10001100101000</pre>

=={{header|QB64}}==

Print DecToBin$(5)

Print DecToBin$(50)

 

</syntaxhighlight>

=={{header|Quackery}}==

Quackery provides built-in radix control, much like Forth.

2 base put ( Numbers will be output in base 2 now. )

( Bases from 2 to 36 (inclusive) are supported. )

A user-defined conversion might look something like this:

[ [] swap

[ 2 /mod digit

10001100101000

</pre>

=={{header|R}}==

dec2bin <- function(num) {

ifelse(num == 0,

10001100101000

</pre>

=={{header|Racket}}==

#lang racket

;; Option 1: binary formatter

(for ([i 16]) (displayln (number->string i 2)))

</syntaxhighlight>

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2015.12}}

<pre>

101

Alternatively:

 

<pre>101

110010

10001100101000</pre>

=={{header|RapidQ}}==

'Convert Integer to binary string

Print "bin 5 = ", bin$(5)

sleep 10

</syntaxhighlight>

=={{header|Red}}==

 

foreach number [5 50 9000] [

9000 10001100101000

</pre>

=={{header|Retro}}==

 

=={{header|REXX}}==

Note: &nbsp; some REXX interpreters have a &nbsp; '''D2B''' &nbsp; [Decimal to Binary] &nbsp; BIF ('''b'''uilt-'''i'''n '''f'''unction).

<br>Programming note: &nbsp; this REXX version depends on &nbsp; '''numeric digits''' &nbsp; 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

This version handles the case of zero as a special case more elegantly.

<br>The following versions depend on the setting of &nbsp; '''numeric digits''' &nbsp; such that the number in decimal can be expressed as a whole number.

@.=; @.1= 0

@.2= 5

===concise version===

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

@.=; @.1= 0

@.2= 5

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

 

=={{header|Ring}}==

see "Number to convert : "

give a

next

</syntaxhighlight>

 

=={{header|Ruby}}==

puts "%b" % n

end</syntaxhighlight>

or

puts n.to_s(2)

end</syntaxhighlight>

 

=={{header|Run BASIC}}==

while 2^(n+1) < a

n = n + 1

<pre>Number to convert:?9000

10001100101000</pre>

=={{header|Rust}}==

for i in 0..8 {

println!("{:b}", i)

110

111</pre>

=={{header|S-lang}}==

{

variable m = 0x40000000, prn = 0, bs = "";

110010

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

 

scala> (9000 toBinaryString)

res2: String = 10001100101000</syntaxhighlight>

=={{header|Scheme}}==

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

(display (number->string 9000 2)) (newline)</syntaxhighlight>

 

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

10000

</pre>

 

=={{header|SequenceL}}==

 

toBinaryString(number(0)) :=

 

=={{header|Sidef}}==

say n.as_bin;

}</syntaxhighlight>

110010

10001100101000</pre>

=={{header|Simula}}==

 

PROCEDURE OUTINTBIN(N); INTEGER N;

10001100101000

</pre>

=={{header|SkookumScript}}==

 

println(50.binary)

println(9000.binary)</syntaxhighlight>

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

or:

=={{header|SNOBOL4}}==

define('bin(n,r)') :(bin_end)

bin bin = le(n,0) r :s(return)

10001100101000

</pre>

=={{header|SNUSP}}==

/recurse\

$,binary!\@\>?!\@/<@\.#

\?!#-?/+# mod2

</syntaxhighlight>

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

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

print (Int.fmt StringCvt.BIN 9000 ^ "\n");</syntaxhighlight>

=={{header|Swift}}==

println(String(num, radix: 2))

}</syntaxhighlight>

110010

10001100101000</pre>

=={{header|Tcl}}==

# Convert to _fixed width_ big-endian 32-bit binary

binary scan [binary format "I" $num] "B*" binval

}</syntaxhighlight>

Demonstrating:

puts [num2bin $x]

}

<br>

Or you can use the builtin format:

puts [format "%4u: %b" $n $n]

}</syntaxhighlight>

50: 110010

9000: 10001100101000</pre>

=={{header|TI-83 BASIC}}==

Using Standard TI-83 BASIC

:Disp "NUMBER TO"

:Disp "CONVERT:"

:Disp B</syntaxhighlight>

Alternate using a string to display larger numbers.

:Input X

:" "→Str1

:Str1</syntaxhighlight>

Using the baseInput() "real(25," function from [http://www.detachedsolutions.com/omnicalc/ Omnicalc]

:Disp "NUMBER TO"

:Disp "CONVERT"

 

More compact version:

:" →Str1

:If not(D:"0→Str1

:Disp Str1

</syntaxhighlight>

=={{header|uBasic/4tH}}==

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

Input "Enter base (1<X<17): "; b

While (b < 2) + (b > 16)

 

=={{header|UNIX Shell}}==

}

 

 

=={{header|VBA}}==

Places is useful for padding the return value with leading 0s (zeros).

 

Option Explicit

 

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 }

10001100101000

</pre>

=={{header|Vim Script}}==

let n = a:n

let s = ""

110010

10001100101000</pre>

=={{header|Visual Basic}}==

{{works with|Visual Basic|VB6 Standard}}

Public Function Bin(ByVal l As Long) As String

Dim i As Long

110010

10001100101000</pre>

=={{header|Visual Basic .NET}}==

Sub Main

For Each number In {5, 50, 9000}

110010

10001100101000</pre>

=={{header|Visual FoxPro}}==

*!* Binary Digits

CLEAR

10001100101000

</pre>

 

=={{header|Whitespace}}==

This program prints binary numbers until the internal representation of the current integer overflows to -1; it will never do so on some interpreters. It is almost an exact duplicate of [[Count in octal#Whitespace]].

 

 

It was generated from the following pseudo-Assembly.

 

; Increment indefinitely.

0:

pop

ret</syntaxhighlight>

 

=={{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)</syntaxhighlight>

To output to the console:

Outputs: <pre>

101

110010

1110000100</pre>

=={{header|Wren}}==

{{libheader|Wren-fmt}}

System.print("Converting to binary:")

=={{header|X86 Assembly}}==

Translation of XPL0. Assemble with tasm, tlink /t

.code

.486

10001100101000

</pre>

=={{header|XPL0}}==

 

proc BinOut(N); \Output N in binary

100000010100001

</pre>

=={{header|Yabasic}}==

a(0) = 5

a(1) = 50

next i

end</syntaxhighlight>

=={{header|Z80 Assembly}}==

{{trans|8086 Assembly}}

 

PrintChar equ &BB5A ;syscall - prints accumulator to Amstrad CPC's screen

 

 

This is another version. Output of the result over port 0A hex.

; HL contains the value to be converted

ld hl,5

djnz bitloop

 

=={{header|zkl}}==

=={{header|ZX Spectrum Basic}}==

20 LET n=50: GO SUB 1000: PRINT s$

30 LET n=9000: GO SUB 1000: PRINT s$