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

{{out}}

<pre>

9000 = 10001100101000

</pre>

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

BINARY CSECT

USING BINARY,R12

CBIN DC CL32' ' binary value

YREGS

{{out}}

<pre>

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

binstr .repeat 16, $00 ; reserve 16 bytes for the binary digits

.byte $0d, $00 ; newline + null terminator

{{out}}

<pre>

100

</pre>

 

{{out}}

110010

</pre>

=={{header|ACL2}}==

 

(defun bin-string-r (x)

(if (zp x)

"0"

 

=={{header|Ada}}==

 

procedure binary is

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

put_line ("Output for" & test'img & " is " & bin_image (test));

end loop;

 

{{out}}

Output for 9000 is 10001100101000

</pre>

=={{header|Aime}}==

o_byte('\n');

o_xinteger(2, 5);

o_xinteger(2, 50);

o_byte('\n');

{{out}}

<pre>0

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

50, " => ", []BOOL(BIN 50)[bits width-6+1:], new line,

9000, " => ", []BOOL(BIN 9000)[bits width-14+1:], new line

{{out}}

<pre>

+9000 => TFFFTTFFTFTFFF

</pre>

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

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

procedure printBinaryDigits( integer value n ) ;

end

 

 

 

=={{header|AppleScript}}==

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

on showBin(n)

script binaryChar

end showBin

 

 

-- showIntAtBase :: Int -> (Int -> Char) -> Int -> String -> String

end if

end showIntAtBase

 

-- quotRem :: Integral a => a -> a -> (a, a)

end quotRem

 

 

 

-- intercalate :: Text -> [Text] -> Text

return strJoined

end intercalate

 

-- map :: (a -> b) -> [a] -> [b]

end tell

end map

 

-- Lift 2nd class handler function into 1st class script wrapper

on unlines(xs)

intercalate(linefeed, xs)

<pre>5 -> 101

50 -> 110010

9000 -> 10001100101000</pre>

 

on showBin(n)

script binaryChar

end script

showIntAtBase(2, binaryChar, n, "")

<pre>5 -> 一〇一

50 -> 一一〇〇一〇

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

 

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

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

.Ls_magic_number_10: .word 0x66666667

 

 

=={{header|AutoHotkey}}==

MsgBox % NumberToBinary(50) ;110010

MsgBox % NumberToBinary(9000) ;10001100101000

Result := (InputNumber & 1) . Result, InputNumber >>= 1

Return, Result

=={{header|AutoIt}}==

ConsoleWrite(IntToBin(50) & @CRLF)

 

Return $r

EndFunc ;==>IntToBin

 

=={{header|AWK}}==

print tobinary(5)

print tobinary(50)

 

function tobinary(num) {

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

End

Disp P,i

=={{header|BaCon}}==

OPTION MEMTYPE int

INPUT n$

ELSE

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

 

 

=={{header|BASIC}}==

 

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

1 LET N2 = ABS ( INT (N))

2 LET B$ = ""

7 NEXT N1

8 PRINT B$

{{out}}

<pre>101

 

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

# DecToBin.bas

# BASIC256 1.1.4.0

print a[i] + chr(9) + toRadix(a[i],2) # radix (decimal, base2)

next i

{{out}}

<pre>

 

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

PRINT FN_tobase(num%, 2, 0)

NEXT

M% -= 1

UNTIL (N%=FALSE OR N%=TRUE) AND M%<=0

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

Here is a faster "Convert to Binary" program:

PRINT FNbinary(50)

PRINT FNbinary(9000)

N% = N% >>> 1 : REM BBC Basic prior to V5 can use N% = N% DIV 2

UNTIL N% = 0

 

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

 

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

100 DEF BIN$(N)

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

150 LOOP WHILE N>0

160 LET BIN$=B$

 

=={{header|bc}}==

{{trans|dc}}

5

50

9000

=={{header|Befunge}}==

Reads the number to convert from standard input.

{{out}}

<pre>9000

10001100101000</pre>

 

=={{header|Bracmat}}==

= bit bits

. :?bits

& put$(str$(!dec ":\n" dec2bin$!dec \n\n))

)

{{out}}

<pre>0:

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

<[[-]<] Zero the tape for the next iteration

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

=={{header|Burlesque}}==

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

101

110010

10001100101000

=={{header|C}}==

Converts int to a string.

#include <stdio.h>

#include <stdlib.h>

ret[bits] = '\0';

return ret;

 

{{out}}

10010

10011</pre>

 

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

#include <iostream>

#include <limits>

print_bin(9000);

}

{{out}}

<pre>

</pre>

Shorter version using bitset

#include <bitset>

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

printBits(50);

printBits(9000);

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

std::cout << ('0' + b & 1) << (!at ? "\n": ""); // '0' or '1'. Add EOL if last bit of num

}

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

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

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

std::cout << ('0' + b & 1) << (!at ? "\n": ""); // '0' or '1'. Add EOL if last bit of num

}

Using bitwise operations with recursion.

#include <iostream>

 

}

}

{{out}}

<pre>

10001100101000

</pre>

=={{header|Ceylon}}==

void printBinary(Integer integer) =>

printBinary(50);

printBinary(9k);

=={{header|Clojure}}==

(Integer/toBinaryString 50)

 

=={{header|COBOL}}==

PROGRAM-ID. SAMPLE.

 

display binary_number

stop run.

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

PROGRAM-ID. binary-conversion.

 

end-perform.

display binary-number.

=={{header|CoffeeScript}}==

new Number(n).toString(2)

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

Just print the number with "~b":

 

; or

 

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

BlackBox Component Builder

MODULE BinaryDigits;

IMPORT StdLog,Strings;

END Do;

END BinaryDigits.

Execute: ^Q BinaryDigits.Do <br/>

{{out}}

50:> 110010

9000:> 10001100101000</pre>

 

=={{header|Crystal}}==

{{trans|Ruby}}

Using an array

puts "%b" % n

Using a tuple

{{out}}

<pre>101

110010

10001100101000</pre>

=={{header|D}}==

import std.stdio;

 

foreach (immutable i; 0 .. 16)

writefln("%b", i);

{{out}}

<pre>0

1110

1111</pre>

=={{header|Dart}}==

if(n<0)

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

// fails due to precision limit

print(binary(0x123456789abcdef));

=={{header|dc}}==

 

{{out}}

110010

10001100101000</pre>

=={{header|Delphi}}==

program BinaryDigit;

{$APPTYPE CONSOLE}

writeln(' 50: ',IntToBinStr(50));

writeln('9000: '+IntToBinStr(9000));

{{out}}

<pre>

</pre>

 

 

 

 

=={{header|Dyalect}}==

 

 

var s = ""

s += "1"

} else if s != "" {

s

}

{{out}}

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

 

=={{header|EasyLang}}==

.

<pre>

101

110010

10001100101000

</pre>

 

=={{header|Elena}}==

import extensions;

 

public program()

{

{

console.printLine(n.toString(2))

}

{{out}}

<pre>

=={{header|Elixir}}==

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

Or, using the pipe operator:

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

 

{{out}}

10001100101000

</pre>

 

=={{header|Erlang}}==

{{out}}

<pre>101

 

=={{header|Euphoria}}==

sequence s

s = {}

puts(1, toBinary(5) & '\n')

puts(1, toBinary(50) & '\n')

 

=== Functional/Recursive ===

include std/convert.e

 

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

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

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

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

 

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

 

// define the function

// use the function

[5; 50; 9000]

 

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

 

// use it with printfn with %a

[5; 50; 9000]

Output (either version):

<pre>

10001100101000

</pre>

=={{header|Factor}}==

 

5 >bin print

50 >bin print

 

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

 

=={{header|Forth}}==

 

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

\ we can easily compile a word into the system to set 'BASE' to 2

 

 

 

\ interactive console test with conversion and binary masking example

 

 

 

 

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

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

 

writeLn(binaryNumber(50));

writeLn(binaryNumber(9000));

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

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

9000 -> binary

9000 -> base2

base2[9000]

base[9000, 2]

=={{header|FunL}}==

 

{{out}}

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

in out

 

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

Next

 

{{out}}

<pre>

10001100101000

</pre>

=={{header|Go}}==

 

import (

fmt.Printf("%b\n", i)

}

{{out}}

<pre>

1111

</pre>

=={{header|Groovy}}==

Solutions:

n binary

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

[5, 50, 9000].each {

printf('%5d %15s\n', it, Integer.toBinaryString(it))

{{out}}

<pre> n binary

50 110010

9000 10001100101000</pre>

=={{header|Haskell}}==

import Numeric

import Text.Printf

 

-- Use the built-in function showIntAtBase.

main = do

putStrLn $ printf "%4s %14s %14s" "N" "toBin" "toBin1"

{{out}}

<pre>

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

}

return reverse(trim(b,"0")) # nothing extraneous

{{out}}

<pre>5 = 101

1285 = 10100000101

9000 = 10001100101000</pre>

=={{header|Idris}}==

 

binaryDigit : Integer -> Char

putStrLn (binaryString 50)

putStrLn (binaryString 9000)

{{out}}

<pre>

10001100101000

</pre>

=={{header|J}}==

tobin 5

101

110010

tobin 9000

 

=={{header|Java}}==

110010

 

=={{header|JavaScript}}==

===ES5===

return new Number(number)

.toString(2);

// alert() in a browser, wscript.echo in WSH, etc.

print(toBinary(demoValues[i]));

 

===ES6===

 

 

 

 

 

 

 

 

 

{{Out}}

<pre>5 -> 101

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:

 

 

 

 

 

 

 

 

 

 

 

 

{{Out}}

<pre>5 -> 一〇一

50 -> 一一〇〇一〇

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

=={{header|Joy}}==

=={{header|jq}}==

 

# The task:

{{Out}}

$ jq -n -r -f Binary_digits.jq

110010

10001100101000

=={{header|Julia}}==

{{works with|Julia|1.0}}

 

 

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

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

@printf("%6i → %s\n", n, string(n, base=2, pad=20))

 

{{out}}

50 → 00000000000000110010

9000 → 00000010001100101000</pre>

=={{header|K}}==

tobin' 5 50 9000

("101"

"110010"

=={{header|Kotlin}}==

val numbers = intArrayOf(5, 50, 9000)

 

{{out}}

<pre>

9000 -> 10001100101000

</pre>

 

=={{header|Lang5}}==

{{out}}

<pre>[

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

 

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)

(list (: erlang integer_to_list x 2))))

(list 5 50 9000))

{{out|note=for both examples}}

<pre>

10001100101000

</pre>

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

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

next

wend

end function

 

=={{header|LLVM}}==

{{trans|C}}

; source_filename = "binary.c"

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

!0 = !{i32 1, !"wchar_size", i32 2}

!1 = !{i32 7, !"PIC Level", i32 2}

{{out}}

<pre>0

10010

10011</pre>

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

20 PRINT BIN$(50)

{{out}}

<pre>101

110010

10001100101000</pre>

=={{header|LOLCODE}}==

HOW IZ I DECIMULBINUR YR DECIMUL

I HAS A BINUR ITZ ""

VISIBLE I IZ DECIMULBINUR YR 50 MKAY

VISIBLE I IZ DECIMULBINUR YR 9000 MKAY

 

{{out}}

 

=={{header|Lua}}==

local bin = ""

bin = n % 2 .. bin

n = math.floor(n / 2)

end

end

 

print(dec2bin(5))

print(dec2bin(50))

{{out}}

<pre>101

 

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

Module Checkit {

Form 90, 40

}

Checkit

{{out}}

<pre style="height:30ex;overflow:scroll">

 

</pre >

 

=={{header|Maple}}==

> convert( 50, 'binary' );

110010

> convert( 9000, 'binary' );

10001100101000

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

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

dec2bin(50)

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

=={{header|MAXScript}}==

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

for k = 0 to 16 do

print binString

)

{{out}}

Output to MAXScript Listener:

"10000"

</pre>

=={{header|Mercury}}==

:- interface.

 

print_binary_digits(N, !IO) :-

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

 

=={{header|min}}==

 

{{out}}

 

=={{header|MiniScript}}==

=== Iterative ===

result = ""

while n

n = floor(n/2)

end while

print binary(50)

print binary(9000)

 

=== Recursive ===

if n == 0 then

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

print binary(50)

print binary(9000)

{{out}}

<pre>

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

;

 

==== from the REPL ====

> binary 9000;

"10001100101000"</pre>

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

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT Write,WriteLn,ReadChar;

 

ReadChar

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

 

IMPORT IO, Fmt;

num := 150;

IO.Put(Fmt.Int(num, 2) & "\n");

{{out}}

<pre>

10010110

</pre>

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

w_ = list.word(n_)

say w_.right(20)':' getBinaryDigits(w_)

{{out}}

<pre>

9000: 10001100101000

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

 

for i in 0..15:

{{out}}

<pre>0

1111</pre>

 

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

MODULE BinaryDigits;

IMPORT Out;

OutBin(42); Out.Ln;

END BinaryDigits.

 

{{out}}

101010

</pre>

=={{header|Objeck}}==

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

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

9000->ToBinaryString()->PrintLine();

}

{{out}}

<pre>

10001100101000

</pre>

=={{header|OCaml}}==

in

 

=={{header|Oforth}}==

ok

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

=={{header|Panda}}==

{{out}}

<pre>0

1110

1111</pre>

=={{header|Pascal}}==

{{works with|Free Pascal}}

FPC compiler Version 2.6 upwards.The obvious version.

{$MODE objFPC}

uses

IntBinTest(5);IntBinTest(50);IntBinTest(5000);

IntBinTest(0);IntBinTest(NativeUint(-1));

{{out}}

<pre> 5 101

Beware of the endianess of the constant.

I check performance with random Data.

program IntToPcharTest;

uses

Writeln(cnt/rounds+1:6:3);

FreeMem(s);

{{out}}

<pre>

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

<@ saybaslit>9000</@>

 

=={{header|Perl}}==

printf "%b\n", $_;

<pre>

101

10001100101000

</pre>

=={{header|Phix}}==

{{out}}

<pre>

10001100101000

</pre>

 

=={{header|PHP}}==

echo decbin(5);

echo decbin(50);

{{out}}

<pre>101

110010

10001100101000</pre>

 

=={{header|PicoLisp}}==

-> "101"

 

 

: (bin 9000)

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

 

put string(text) edit (2147483647) (b);

{{out}}

<pre>

1111111111111111111111111111111

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

PRINT STR$(d(i)) & ": " & BIN$(d(i)) & " (" & BIN$(d(i), 32) & ")"

NEXT i

{{out}}<pre>

5: 101 (00000000000000000000000000000101)

9000: 10001100101000 (00000000000000000010001100101000)

</pre>

=={{header|PowerShell}}==

{{libheader|Microsoft .NET Framework}}

{{out}}

<pre>101

110010

1110000100</pre>

=={{header|Processing}}==

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

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

println(binary(50)); // 00000000110010

=={{header|Prolog}}==

{{works with|SWI Prolog}}

{{works with|GNU Prolog}}

binary(X) :- format('~2r~n', [X]).

main :- maplist(binary, [5,50,9000]), halt.

{{out}}

<pre>101

110010

10001100101000</pre>

=={{header|PureBasic}}==

PrintN(Bin(5)) ;101

PrintN(Bin(50)) ;110010

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

{{out}}

<pre>101

110010

10001100101000</pre>

=={{header|Python}}==

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

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

 

0

1101

1110

 

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

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

 

0

1101

1110

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

1101

1110

 

===Custom functions===

 

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

 

 

 

if __name__ == '__main__':

{{Out}}

<pre>Mapping showBinary over integer list:

 

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

 

 

# MAIN -------------------------------------------------

if __name__ == '__main__':

{{Out}}

<pre>Mapping a composed function:

50 -> 110010

9000 -> 10001100101000</pre>

=={{header|R}}==

dec2bin <- function(num) {

ifelse(num == 0,

cat(dec2bin(anumber),"\n")

}

'''output'''

<pre>

10001100101000

</pre>

=={{header|Racket}}==

#lang racket

;; Option 1: binary formatter

;; Option 2: explicit conversion

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

=={{header|RapidQ}}==

'Convert Integer to binary string

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

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

sleep 10

=={{header|Red}}==

 

foreach number [5 50 9000] [

print reduce [ pad/left number 5 binstr ]

]

'''output'''

<pre> 5 101

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

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

{{out|output}}

<pre>

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

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

{{out|output|text=&nbsp; is identical to the 1^st REXX version.}} <br><br>

 

===concise version===

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

@.=; @.1= 0

@.2= 5

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

{{out|output|text=&nbsp; is identical to the 1^st REXX version.}} <br><br>

 

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

if y=='' then y=0 /*handle the special case of 0 (zero).*/

say y /*display binary number to the terminal*/

{{out|output}}

<pre>

 

=={{header|Ring}}==

see "Number to convert : "

give a

else see 0 ok

next

 

=={{header|Ruby}}==

puts "%b" % n

or

puts n.to_s(2)

{{out}}

<pre>101

 

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

while 2^(n+1) < a

n = n + 1

print 0;

end if

{{out}}

<pre>Number to convert:?9000

10001100101000</pre>

=={{header|Rust}}==

for i in 0..8 {

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

}

Outputs:

<pre>0

110

111</pre>

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

{

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

() = printf("%s\n", int_to_bin(5));

() = printf("%s\n", int_to_bin(50));

{{out}}

<pre>101

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)

=={{header|Scheme}}==

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

 

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

writeln(number radix 2);

end for;

{{out}}

<pre>

1111

10000

</pre>

 

=={{header|Sidef}}==

say n.as_bin;

{{out}}

<pre>101

10001100101000</pre>

=={{header|Simula}}==

 

PROCEDURE OUTINTBIN(N); INTEGER N;

END;

 

{{out}}

<pre>

10001100101000

</pre>

=={{header|SkookumScript}}==

 

println(50.binary)

Or looping over a list of numbers:

{{out}}

<pre>101

110010

10001100101000</pre>

=={{header|Smalltalk}}==

50 printOn: Stdout radix:2

or:

 

=={{header|SNUSP}}==

/recurse\

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

/<+>- \ div2

\?!#-?/+# mod2

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

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

=={{header|Swift}}==

println(String(num, radix: 2))

{{out}}

<pre>

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]

}

puts [num2bin 5]

puts [num2bin 50]

{{out}}

<pre>

10001100101000

</pre>

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

Using Standard TI-83 BASIC

:Disp "NUMBER TO"

:Disp "CONVERT:"

:N-1→N

:End

Alternate using a string to display larger numbers.

:Input X

:" "→Str1

:iPart(X)→X

:End

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

:Disp "NUMBER TO"

:Disp "CONVERT"

:Input "Str1"

 

More compact version:

:" →Str1

:If not(D:"0→Str1

:End

:Disp Str1

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

130 Print "D"; : Return

140 Print "E"; : Return

{{out}}

<pre>Enter base (1<X<17): 2

 

0 OK, 0:775</pre>

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

}

 

 

=={{header|VBA}}==

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

 

Option Explicit

 

End If

End Function

{{out}}

<pre>The decimal value 5 should produce an output of : 101

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 }

EOL

Ins_Newline

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

<pre>

10001100101000

</pre>

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

let n = a:n

let s = ""

echo Num2Bin(5)

echo Num2Bin(50)

 

{{Out}}

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

Debug.Print Bin(9000)

End Sub

{{out}}

<pre>101

110010

10001100101000</pre>

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

Sub Main

For Each number In {5, 50, 9000}

Next

End Sub

{{out}}

<pre>101

110010

10001100101000</pre>

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

*!* Binary Digits

CLEAR

RETURN FLOOR(v)

ENDFUNC

{{out}}

<pre>

10001100101000

</pre>

 

=={{header|Whitespace}}==