User Rating 0.0 ★★★★★

Total Usage 0 times

Category Math & Algebra

Decimal Number

Supports integers from −2,147,483,648 to 9,007,199,254,740,991

Bit Width (negative numbers)

Group bits (4-bit nibbles)

Pad to bit width

Quick values:

Binary Result

Recursion Steps

Depth	Call	n ÷ 2	Quotient	Remainder (bit)

Hexadecimal

Octal

Total Bits

Recursion Depth

Is this tool helpful?

Your feedback helps us improve.

★ ★ ★ ★ ★

About

Converting a decimal integer to its binary representation is a fundamental operation in computer science, underpinned by repeated Euclidean division by 2. The recursive approach mirrors the mathematical definition directly: the binary representation of n is the binary representation of n ÷ 2 (integer quotient) concatenated with n mod 2. Each recursion level extracts one bit. The base case fires when the quotient reaches 0. An incorrect implementation silently drops leading zeros or mishandles the base case, producing wrong results that propagate through downstream bitwise operations, protocol encodings, or hardware register mappings.

This tool executes real recursive division and exposes every stack frame. It handles non-negative integers up to 2⁵³ − 1 (the JavaScript safe integer boundary defined by IEEE 754 double-precision). For negative inputs, two's complement encoding is applied at 8, 16, or 32-bit widths. The tool approximates nothing. Every displayed bit is computed, not looked up.

Formulas

The recursive decimal-to-binary conversion rests on the identity that any non-negative integer n in base 10 can be decomposed by repeated division by 2.

toBinary(n) =

{

0 if n = 0toBinary(⌊n2⌋) + (n mod 2) otherwise

Where n = the input decimal integer, ⌊ ⌋ = floor division (integer quotient), mod = modulo operator returning the remainder. The recursion depth equals ⌊log₂(n)⌋ + 1 for n > 0. The total number of bits in the binary output equals the recursion depth. For negative numbers, two's complement is computed as 2^w + n where w is the bit width (8, 16, or 32).

Reference Data

Decimal	Binary	Hex	Octal	Bits Required	Recursion Depth
0	0	0	0	1	0
1	1	1	1	1	1
2	10	2	2	2	2
7	111	7	7	3	3
8	1000	8	10	4	4
10	1010	A	12	4	4
15	1111	F	17	4	4
16	10000	10	20	5	5
42	101010	2A	52	6	6
98	1100010	62	142	7	7
107	1101011	6B	153	7	7
127	1111111	7F	177	7	7
128	10000000	80	200	8	8
255	11111111	FF	377	8	8
256	100000000	100	400	9	9
1000	1111101000	3E8	1750	10	10
1023	1111111111	3FF	1777	10	10
1024	10000000000	400	2000	11	11
4096	1000000000000	1000	10000	13	13
65535	1111111111111111	FFFF	177777	16	16

Frequently Asked Questions

When n = 1, the division ⌊1 ÷ 2⌋ yields 0 with remainder 1. If you stopped at 1 instead of 0, you would need special handling to prepend the final 1 bit. Stopping at 0 means every remainder (including the most-significant bit) is captured uniformly within the recursive call, producing the correct result without edge-case branching.

Two's complement encodes negative integers by computing 2^w + n, where w is the chosen bit width and n is negative. For example, −5 in 8-bit: 2⁸ + (−5) = 251, which converts to 11111011. The most-significant bit is always 1 for negative values. If the magnitude exceeds the width's range (−129 for 8-bit), you must select a wider bit width.

The converter supports integers from −2,147,483,648 (32-bit two's complement minimum) to 9,007,199,254,740,991 (2⁵³ − 1), which is Number.MAX_SAFE_INTEGER in JavaScript. Beyond this, IEEE 754 double-precision loses integer precision and the conversion produces incorrect bits.

For n > 0, recursion depth equals ⌊log₂(n)⌋ + 1, which is exactly the number of binary digits. Each recursive call extracts one bit via mod 2. For n = 255, depth is ⌊7.99⌋ + 1 = 8, yielding 11111111.

No. Leading zeros do not alter the value of a binary number, just as leading zeros in decimal do not change 007 from equaling 7. Padding to 8, 16, or 32 bits is a formatting convention used to align with standard register widths and byte boundaries. This tool pads to the nearest standard width when grouping is enabled.

Both approaches produce identical output. The recursive method directly mirrors the mathematical recurrence relation: toBinary(n) = toBinary(⌊n÷2⌋) + (n mod 2). This makes it a canonical teaching tool for understanding both recursion and number systems simultaneously. The call stack naturally reverses the bit order, eliminating the need for an explicit string reversal step required by iterative approaches.