Program for Decimal to Binary Conversion
Last Updated :
21 Jun, 2025
Given a non negative number n, the task is to convert the given number into an equivalent binary representation.
Examples:
Input: n = 12
Output: "1100"
Explanation: the binary representation of 12 is "1100", since 12 = 1×23 + 1×22 + 0×21+ 0×20 = 12
Input: n = 33
Output: "100001"
Explanation: the binary representation of 33 is "100001", since 1×25 + 0×24 + 0×23 + 0×22 + 0×21 + 1×20 = 33
[Approach - 1] Division by 2 - O(log₂(n)) Time and O(log₂(n)) Space
To convert a decimal number to binary, repeatedly divide it by 2 and record the remainders. Reading these remainders in reverse gives the binary representation.
C++
#include <iostream>
#include <algorithm>
using namespace std;
string decToBinary(int n) {
string bin = "";
while (n > 0) {
// checking the mod
int bit = n%2;
bin.push_back('0' + bit);
n /= 2;
}
// reverse the string
reverse(bin.begin(), bin.end());
return bin;
}
int main() {
int n = 12;
cout << decToBinary(n);
return 0;
}
#include <stdio.h>
#include <string.h>
// function to reverse the string
void reverse(char *bin, int left, int right) {
while (left < right) {
char temp = bin[left];
bin[left] = bin[right];
bin[right] = temp;
left++;
right--;
}
}
// function to convert decimal to binary
char* decToBinary(int n) {
int index = 0;
char* bin = (char*) malloc(32 * sizeof(char));
while (n > 0) {
int bit = n % 2;
bin[index++] = '0' + bit;
n /= 2;
}
bin[index] = '\0';
// Reverse the binary string
reverse(bin, 0, index-1);
return bin;
}
int main() {
int n = 12;
char* bin = decToBinary(n);
printf("%s", bin);
return 0;
}
import java.util.*;
class GfG {
static String decToBinary(int n) {
StringBuilder bin = new StringBuilder();
while (n > 0) {
int bit = n % 2;
bin.append((char) ('0' + bit));
n /= 2;
}
// reverse the string
bin.reverse();
return bin.toString();
}
public static void main(String[] args) {
int n = 12;
System.out.println(decToBinary(n));
}
}
# function to convert decimal to binary
def decToBinary(n):
binArr = []
while n > 0:
bit = n % 2
binArr.append(str(bit))
n //= 2
# reverse the string
binArr.reverse()
return "".join(binArr)
if __name__ == "__main__":
n = 12
print(decToBinary(n))
using System;
using System.Collections.Generic;
class GfG {
// function to convert decimal to binary
static string decToBinary(int n) {
List<char> bin = new List<char>();
while (n > 0) {
int bit = n % 2;
bin.Add((char)('0' + bit));
n /= 2;
}
// reverse the string
bin.Reverse();
return new string(bin.ToArray());
}
static void Main() {
int n = 12;
Console.WriteLine(decToBinary(n));
}
}
// Function to convert decimal to binary
function decToBinary(n) {
let bin = [];
while (n > 0) {
let bit = n % 2;
bin.push(String(bit));
n = Math.floor(n / 2);
}
// reverse the string
bin.reverse();
return bin.join("");
}
// Driver Code
let n = 12;
console.log(decToBinary(n));
[Approach - 2] Using Head Recursion - O(log₂(n)) Time and O(log₂(n)) Space
The idea is same as the previous approach, but we will use recursion to generate the binary equivalent number.
C++
#include <iostream>
#include <algorithm>
using namespace std;
// Recursive function to convert decimal to binary
void decToBinaryRec(int n, string &bin) {
// Base Case
if (n==0)
return;
// Recur for smaller bits.
decToBinaryRec(n/2, bin);
// Add MSB of current number to the binary string
bin.push_back(n%2 + '0');
}
// Function to convert decimal to binary
string decToBinary(int n) {
if (n == 0)
return "0";
string bin = "";
decToBinaryRec(n, bin);
return bin;
}
int main() {
int n = 12;
cout << decToBinary(n);
return 0;
}
class GfG {
// Recursive function to convert decimal to binary
static void decToBinaryRec(int n, StringBuilder bin) {
// Base Case
if (n == 0)
return;
// Recur for smaller bits.
decToBinaryRec(n / 2, bin);
// Add MSB of current number to the binary string
bin.append(n % 2);
}
// Function to convert decimal to binary
static String decToBinary(int n) {
if (n == 0)
return "0";
StringBuilder bin = new StringBuilder();
decToBinaryRec(n, bin);
return bin.toString();
}
public static void main(String[] args) {
int n = 12;
System.out.println(decToBinary(n));
}
}
def decToBinaryRec(n, binArr):
# Base Case
if n == 0:
return
# Recur for smaller bits.
decToBinaryRec(n // 2, binArr)
# Add MSB of current number to the binary list
binArr.append(str(n % 2))
# Function to convert decimal to binary
def decToBinary(n):
if n == 0:
return "0"
binArr = []
decToBinaryRec(n, binArr)
return "".join(binArr)
if __name__ == "__main__":
n = 12
print(decToBinary(n))
using System;
using System.Text;
class GfG {
// Recursive function to convert decimal to binary
static void decToBinaryRec(int n, StringBuilder bin) {
// Base Case
if (n == 0)
return;
// Recur for smaller bits.
decToBinaryRec(n / 2, bin);
// Add MSB of current number to the binary string
bin.Append(n % 2);
}
// Function to convert decimal to binary
static string decToBinary(int n) {
if (n == 0)
return "0";
StringBuilder bin = new StringBuilder();
decToBinaryRec(n, bin);
return bin.ToString();
}
static void Main() {
int n = 12;
Console.WriteLine(decToBinary(n));
}
}
function decToBinaryRec(n, bin) {
// Base Case
if (n === 0)
return;
// Recur for smaller bits.
decToBinaryRec(Math.floor(n / 2), bin);
// Add MSB of current number to the binary string
bin.push(n % 2);
}
// Function to convert decimal to binary
function decToBinary(n) {
if (n === 0)
return "0";
let bin = [];
decToBinaryRec(n, bin);
return bin.join("");
}
// Driver code
let n = 12;
console.log(decToBinary(n));
[Approach - 3] Using Bitwise Operators - O(log₂(n)) Time and O(log₂(n)) Space
Using bitwise operators, we can extract binary digits by checking the least significant bit (n & 1) and then right-shifting the number (n >> 1) to process the next bit.
This method is faster than arithmetic division and modulo, as bitwise operations are more efficient at the hardware level.
C++
#include <iostream>
#include <algorithm>
using namespace std;
string decToBinary(int n) {
// String to store the binary representation
string bin = "";
while (n > 0) {
// Finding (n % 2) using bitwise AND operator
// (n & 1) gives the least significant bit (LSB)
int bit = n & 1;
bin.push_back('0' + bit);
// Right shift n by 1 (equivalent to n = n / 2)
// This removes the least significant bit (LSB)
n = n >> 1;
}
reverse(bin.begin(), bin.end());
return bin;
}
int main() {
int n = 12;
cout << decToBinary(n);
return 0;
}
#include <stdio.h>
#include <string.h>
// Function to Reverse the string
void reverse(char *bin, int left, int right) {
while (left < right) {
char temp = bin[left];
bin[left] = bin[right];
bin[right] = temp;
left++;
right--;
}
}
// function to convert decimal to binary
char* decToBinary(int n) {
int index = 0;
char* bin = (char*) malloc(32 * sizeof(char));
while (n > 0) {
// Finding (n % 2) using bitwise AND operator
// (n & 1) gives the least significant bit (LSB)
int bit = n & 1;
bin[index++] = '0' + bit;
// Right shift n by 1 (equivalent to n = n / 2)
// This removes the least significant bit (LSB)
n = n >> 1;
}
bin[index] = '\0';
// Reverse the binary string
reverse(bin, 0, index-1);
return bin;
}
int main() {
int n = 12;
char* bin = decToBinary(n);
printf("%s", bin);
return 0;
}
import java.util.*;
class GfG {
static String decToBinary(int n) {
// String to store the binary representation
StringBuilder bin = new StringBuilder();
while (n > 0) {
// Finding (n % 2) using bitwise AND operator
// (n & 1) gives the least significant bit (LSB)
int bit = n & 1;
bin.append(bit);
// Right shift n by 1 (equivalent to n = n / 2)
// This removes the least significant bit (LSB)
n = n >> 1;
}
return bin.reverse().toString();
}
public static void main(String[] args) {
int n = 12;
System.out.println(decToBinary(n));
}
}
def decToBinary(n):
# String to store the binary representation
bin = ""
while n > 0:
# Finding (n % 2) using bitwise AND operator
# (n & 1) gives the least significant bit (LSB)
bit = n & 1
bin += str(bit)
# Right shift n by 1 (equivalent to n = n // 2)
# This removes the least significant bit (LSB)
n = n >> 1
return bin[::-1]
if __name__ == "__main__":
n = 12
print(decToBinary(n))
using System;
using System.Text;
class GfG {
// Function to convert decimal to binary
static string decToBinary(int n) {
// String to store the binary representation
StringBuilder bin = new StringBuilder();
while (n > 0) {
// Finding (n % 2) using bitwise AND operator
// (n & 1) gives the least significant bit (LSB)
int bit = n & 1;
bin.Append(bit);
// Right shift n by 1 (equivalent to n = n / 2)
// This removes the least significant bit (LSB)
n = n >> 1;
}
char[] arr = bin.ToString().ToCharArray();
Array.Reverse(arr);
return new string(arr);
}
static void Main() {
int n = 12;
Console.WriteLine(decToBinary(n));
}
}
function decToBinary(n) {
// String to store the binary representation
let bin = "";
while (n > 0) {
// Finding (n % 2) using bitwise AND operator
// (n & 1) gives the least significant bit (LSB)
let bit = n & 1;
bin += bit;
// Right shift n by 1 (equivalent to n = Math.floor(n / 2))
// This removes the least significant bit (LSB)
n = n >> 1;
}
return bin.split("").reverse().join("");
}
// Driver code
let n = 12;
console.log(decToBinary(n));
[Approach - 4] Using Built-in Methods - O(log₂(n)) Time and O(log₂(n)) Space
The main idea is to leverage built-in functions provided by programming languages to directly convert a decimal number to its binary form. These functions abstract away the underlying logic and return the binary representation as a string, making the process quick, concise, and error-free.
C++
#include <iostream>
#include <cmath>
#include <bitset>
#include <string>
using namespace std;
string decToBinary(int n) {
int len = (int)(log2(n));
// Store in bitset to get the binary representation,
// then convert it to string
// and finally remove the prefix zeroes
return bitset<64>(n).to_string().substr(64 - len - 1);
}
int main() {
int n = 12;
cout << decToBinary(n);
return 0;
}
class GfG {
static String decToBinary(int n) {
int len = (int)(Math.log(n) / Math.log(2));
// Convert to binary string and remove leading zeros
return String.format("%s", Integer.toBinaryString(n));
}
public static void main(String[] args) {
int n = 12;
System.out.println(decToBinary(n));
}
}
import math
def decToBinary(n):
return bin(n)[2::]
if __name__ == "__main__":
n = 12
print(decToBinary(n))
using System;
class GfG {
static string decToBinary(int n) {
// Convert the integer 'n' to its binary representation using base 2
// Convert.ToString(n, 2) converts the number to a string in binary
return Convert.ToString(n, 2);
}
static void Main() {
int n = 12;
Console.WriteLine(decToBinary(n));
}
}
function decToBinary(n) {
// Use toString(2) to convert the
// number to a binary string
return n.toString(2);
}
// Driver Code
let n = 12;
console.log(decToBinary(n));
Similar Reads
Counters in Digital Logic A Counter is a device which stores (and sometimes displays) the number of times a particular event or process has occurred, often in relationship to a clock signal. Counters are used in digital electronics for counting purpose, they can count specific event happening in the circuit. For example, in
4 min read
Ring Counter in Digital Logic A ring counter is a typical application of the Shift register. The ring counter is almost the same as the shift counter. The only change is that the output of the last flip-flop is connected to the input of the first flip-flop in the case of the ring counter but in the case of the shift register it
7 min read
n-bit Johnson Counter in Digital Logic Prerequisite - Counters Johnson counter also known as creeping counter, is an example of synchronous counter. In Johnson counter, the complemented output of last flip flop is connected to input of first flip flop and to implement n-bit Johnson counter we require n flip-flop. It is one of the most im
5 min read
Ripple Counter in Digital Logic Counters play a crucial role in digital logic circuits, enabling tasks such as clock frequency division and sequencing. This article explores the concept of ripple counters, a type of asynchronous counter, their operation, advantages, and disadvantages in digital logic design. What is a Counter?Coun
5 min read
Design counter for given sequence A Counter is a device which stores (and sometimes displays) the number of times a particular event or process has occurred, often in relationship to a clock signal. Counters are used in digital electronics for counting purpose, they can count specific event happening in the circuit. For example, in
3 min read
Master-Slave JK Flip Flop Prerequisite -Flip-flop types and their ConversionRace Around Condition In JK Flip-flop - For J-K flip-flop, if J=K=1, and if clk=1 for a long period of time, then Q output will toggle as long as CLK is high, which makes the output of the flip-flop unstable or uncertain. This problem is called race
4 min read
Asynchronous Sequential Circuits An asynchronous sequential circuit does not have the clock signal; the transitions between different states occur due to the ‘change of inputs’. This makes them suitable for applications which involve low power input or when a clock signal may not be needed. In this article, we explain how these cir
6 min read
Shift Registers in Digital Logic Pre-Requisite: Flip-FlopsFlip flops can be used to store a single bit of binary data (1 or 0). However, in order to store multiple bits of data, we need multiple flip-flops. N flip flops are to be connected in order to store n bits of data. A Register is a device that is used to store such informati
8 min read
Design 101 sequence detector (Mealy machine) A sequence detector is a sequential state machine that takes an input string of bits and generates an output 1 whenever the target sequence has been detected. In a Mealy machine, output depends on the present state and the external input (x). Hence, in the diagram, the output is written outside the
5 min read
Amortized analysis for increment in counter Amortized analysis refers to determining the time-averaged running time for a sequence (not an individual) operation. It is different from average case analysis because here, we don't assume that the data arranged in average (not very bad) fashion like we do for average case analysis for quick sort.
4 min read