Binary digits: Difference between revisions

=={{header|0815}}==

}:b: Treat the queue as a stack and

<:2:= accumulate the binary digits

^:p:

<:a:~$ Output a newline.

{{out}}

Note that 0815 reads numeric input in hexadecimal.

101

110010

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

{{out}}

<pre>

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

BINARY CSECT

USING BINARY,R12

CBIN DC CL32' ' binary value

YREGS

{{out}}

<pre>

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>

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

puts: equ 9h ; Print string

org 100h

jmp binlp ; Otherwise, do next bit

binstr: db '0000000000000000' ; Placeholder for string

{{out}}

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

.stack 1024

.data

pop ax

ret

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

2 base drop

#50 . cr

{{out}}

<pre>

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program binarydigit.s */

.include "../includeARM64.inc"

{{out}}

<pre>

=={{header|ACL2}}==

(defun bin-string-r (x)

(if (zp x)

"0"

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

CHAR ARRAY a(16)

BYTE i=[0]

PutE()

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Binary_digits.png Screenshot from Atari 8-bit computer]

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

=={{header|Aime}}==

o_byte('\n');

o_xinteger(2, 5);

o_xinteger(2, 50);

o_byte('\n');

{{out}}

<pre>0

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

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

procedure writebin(n);

integer n;

writebin(50);

writebin(9000);

{{out}}

<pre>101

A builtin function. Produces a boolean array.

Produces a boolean array.

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

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

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

procedure printBinaryDigits( integer value n ) ;

end

=={{header|AppleScript}}==

(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

on unlines(xs)

intercalate(linefeed, xs)

<pre>5 -> 101

50 -> 110010

Or using:

on showBin(n)

script binaryChar

end script

showIntAtBase(2, binaryChar, n, "")

{{Out}}

<pre>5 -> 一〇一

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

intToBinary(5) & linefeed & ¬

intToBinary(50) & linefeed & ¬

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(5) & linefeed & ¬

intToBinary(50) & linefeed & ¬

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

.Ls_magic_number_10: .word 0x66666667

=={{header|Arturo}}==

print as.binary 50

{{out}}

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

}

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

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

130 : N1 = INT(N1/2)

140 NEXT N1

{{Out}}

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

N = ABS(INT(N))

B$ = ""

PRINT USING fmt$; 5; BIN$(5)

PRINT USING fmt$; 50; BIN$(50)

==={{header|Tiny BASIC}}===

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

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

REM X: number whose binary expansion we want

999 PRINT 0 REM zero is the one time we DO want to print a leading zero

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

LET N = ABS(INT(N))

LET B$ = ""

PRINT USING "####": 9000;

PRINT " -> "; BIN$(9000)

=={{header|Bash}}==

function to_binary () {

if [ $1 -ge 0 ]

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

done

{{out}}

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

:num2bin IntVal [RtnVar]

setlocal enableDelayedExpansion

if "%~2" neq "" (set %~2=%rtn%) else echo %rtn%

)

=={{header|bc}}==

{{trans|dc}}

5

50

9000

=={{header|BCPL}}==

let writebin(x) be

writebin(50)

writebin(9000)

{{out}}

<pre>101

=={{header|Beads}}==

calc main_init

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

{{out}}

<pre>101

=={{header|Befunge}}==

Reads the number to convert from standard input.

{{out}}

<pre>9000

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

=={{header|Bracmat}}==

= bit bits

. :?bits

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

)

{{out}}

<pre>0:

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

===With bit level operations===

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

return EXIT_SUCCESS;

}

{{output}}

<pre>itoa: 5 decimal = 101 binary

===With malloc and log10===

Converts int to a string.

#include <stdio.h>

#include <stdlib.h>

ret[bits] = '\0';

return ret;

{{out}}

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

class Program

}

}

using System.Text;

Console.WriteLine(ToBinary(5));

Console.WriteLine(ToBinary(50));

{{out}}

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

=={{header|Ceylon}}==

void printBinary(Integer integer) =>

printBinary(50);

printBinary(9k);

=={{header|Clojure}}==

(Integer/toBinaryString 50)

=={{header|CLU}}==

bin: string := ""

while n > 0 do

stream$putl(po, int$unparse(test) || " -> " || binary(test))

end

{{out}}

<pre>5 -> 101

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

=={{header|Cowgol}}==

sub print_binary(n: uint32) is

print_binary(5);

print_binary(50);

{{out}}

<pre>101

{{trans|Ruby}}

Using an array

puts "%b" % n

Using a tuple

{{out}}

<pre>101

=={{header|D}}==

import std.stdio;

foreach (immutable i; 0 .. 16)

writefln("%b", i);

{{out}}

<pre>0

=={{header|Dart}}==

if(n<0)

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

// fails due to precision limit

print(binary(0x123456789abcdef));

=={{header|dc}}==

{{out}}

=={{header|Delphi}}==

program BinaryDigit;

{$APPTYPE CONSOLE}

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

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

{{out}}

<pre>

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

var s = ""

for x in 31^-1..0 {

}

{{out}}

=={{header|EasyLang}}==

if n > 0

call to2 n div 2 r$

call pr2 5

call pr2 50

<pre>

=={{header|EchoLisp}}==

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

110010

10001100101000

=={{header|Elena}}==

ELENA 5.0 :

import extensions;

console.printLine(n.toString(2))

}

{{out}}

<pre>

=={{header|Elixir}}==

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

IO.puts Integer.to_string(5,2)

Or, using the pipe operator:

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

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

{{out}}

=={{header|Epoxy}}==

var c:""

while a>0 do

iter Value of List do

log(Value+": "+bin(Value,false))

{{out}}

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

=={{header|Factor}}==

5 >bin print

50 >bin print

=={{header|FALSE}}==

5 b;!

50 b;!

{{out}}

<pre>101

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

01.20 S A=50;D 2

01.30 S A=9000;D 2

02.50 I (-BX)2.4;T !;R

02.60 I (-BD(BX))2.7;T "0";R

{{out}}

<pre>101

=={{header|Forth}}==

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

decimal

{{out}}

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

' FreeBASIC v1.05.0 win64

Dim As String fmt = "#### -> &"

Sleep

End

{{out}}

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

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

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

include "NSLog.incl"

HandleEvents

{{output}}

<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

Next

{{out}}

<pre>

=={{header|Go}}==

import (

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

}

{{out}}

<pre>

=={{header|Groovy}}==

Solutions:

n binary

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

[5, 50, 9000].each {

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

{{out}}

<pre> n binary

=={{header|Haskell}}==

import Numeric

import Text.Printf

main = do

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

{{out}}

<pre>

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

import Data.List (unfoldr)

import Data.Tuple (swap)

)

)

{{Out}}

<pre>5 -> 101

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

=={{header|Idris}}==

binaryDigit : Integer -> Char

putStrLn (binaryString 50)

putStrLn (binaryString 9000)

{{out}}

<pre>

=={{header|J}}==

tobin 5

101

110010

tobin 9000

Algorithm: Remove spaces from the character list which results from formatting the binary list which represents the numeric argument.

=={{header|Java}}==

public static void main(String[] args) {

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

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

}

{{out}}

<pre>101

=={{header|JavaScript}}==

===ES5===

return new Number(number)

.toString(2);

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

print(toBinary(demoValues[i]));

===ES6===

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

"use strict";

// MAIN ---

return main();

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

"use strict";

// MAIN ---

return main();

{{Out}}

<pre>5 -> 一〇一

=={{header|Joy}}==

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

IN

int2bin == [null] [48 + putch] [_] ifte '\n putch

Using int2bin:

0 int2bin

5 int2bin

50 int2bin

=={{header|jq}}==

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

# The task:

{{Out}}

$ jq -n -r -f Binary_digits.jq

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

=={{header|K}}==

tobin' 5 50 9000

("101"

"110010"