Related Articles

# Find the number obtained after concatenation of binary representation of M and N

• Difficulty Level : Expert
• Last Updated : 21 Apr, 2021

Given two integers M and N the task is to find the number formed by concatenating the binary equivalents of M and N i.e. M + N.

Examples:

Input: M = 4, N = 5
Output: 37
Binary equivalent of 4 is 100 and for 5 it is 101
after concatenation, the resultant binary number
formed is 100101 whose decimal equivalent is 37.

Input: M = 3, N = 4
Output: 28

Approach: Convert both the numbers M and N into there binary equivalents then concatenate these numbers as M + N and print the decimal equivalent of the resulting binary number formed after concatenation.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to convert decimal number n``// to its binary representation``// stored as an array arr[]``void` `decBinary(``int` `arr[], ``int` `n)``{``    ``int` `k = log2(n);``    ``while` `(n > 0) {``        ``arr[k--] = n % 2;``        ``n /= 2;``    ``}``}` `// Funtion to convert the number``// represented as a binary array``// arr[] into its decimal equivalent``int` `binaryDec(``int` `arr[], ``int` `n)``{``    ``int` `ans = 0;``    ``for` `(``int` `i = 0; i < n; i++)``        ``ans += arr[i] << (n - i - 1);``    ``return` `ans;``}` `// Function to concatenate the binary``// numbers and return the decimal result``int` `concat(``int` `m, ``int` `n)``{` `    ``// Number of bits in both the numbers``    ``int` `k = log2(m) + 1;``    ``int` `l = log2(n) + 1;` `    ``// Convert the bits in both the integers``    ``// to the arrays a[] and b[]``    ``int` `a[k] = { 0 }, b[l] = { 0 };` `    ``// c[] will be the binary array``    ``// for the result``    ``int` `c[k + l] = { 0 };``    ``decBinary(a, m);``    ``decBinary(b, n);` `    ``// Update the c[] array``    ``int` `in = 0;``    ``for` `(``int` `i = 0; i < k; i++)``        ``c[in++] = a[i];``    ``for` `(``int` `i = 0; i < l; i++)``        ``c[in++] = b[i];` `    ``// Return the decimal equivalent``    ``// of the result``    ``return` `(binaryDec(c, k + l));``}` `// Driver code``int` `main()``{``    ``int` `m = 4, n = 5;` `    ``cout << concat(m, n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``class` `GFG``{``    ` `    ``// Function to convert decimal number n``    ``// to its binary representation``    ``// stored as an array arr[]``    ``static` `void` `decBinary(``int` `arr[], ``int` `n)``    ``{``        ``int` `k = (``int``)(Math.log(n) /``                      ``Math.log(``2``));``        ` `        ``while` `(n > ``0``)``        ``{``            ``arr[k--] = n % ``2``;``            ``n /= ``2``;``        ``}``    ``}``    ` `    ``// Funtion to convert the number``    ``// represented as a binary array``    ``// arr[] into its decimal equivalent``    ``static` `int` `binaryDec(``int` `arr[], ``int` `n)``    ``{``        ``int` `ans = ``0``;``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``ans += arr[i] << (n - i - ``1``);``        ``return` `ans;``    ``}``    ` `    ``// Function to concatenate the binary``    ``// numbers and return the decimal result``    ``static` `int` `concat(``int` `m, ``int` `n)``    ``{``    ` `        ``// Number of bits in both the numbers``        ``int` `k = (``int``)(Math.log(m) /``                      ``Math.log(``2``)) + ``1``;``        ``int` `l = (``int``)(Math.log(n) /``                      ``Math.log(``2``)) + ``1``;``    ` `        ``// Convert the bits in both the integers``        ``// to the arrays a[] and b[]``        ``int` `a[] = ``new` `int``[k];``        ``int` `b[] = ``new` `int``[l];``    ` `        ``// c[] will be the binary array``        ``// for the result``        ``int` `c[] = ``new` `int``[k + l];``        ``decBinary(a, m);``        ``decBinary(b, n);``    ` `        ``// Update the c[] array``        ``int` `in = ``0``;``        ``for` `(``int` `i = ``0``; i < k; i++)``            ``c[in++] = a[i];``        ``for` `(``int` `i = ``0``; i < l; i++)``            ``c[in++] = b[i];``    ` `        ``// Return the decimal equivalent``        ``// of the result``        ``return` `(binaryDec(c, k + l));``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `main (String[] args)``    ``{``        ``int` `m = ``4``, n = ``5``;``    ` `        ``System.out.println(concat(m, n));``    ``}``}` `// This code is contributed by AnkitRai01`

## Python3

 `# Python3 implementation of the approach``import` `math` `# Function to convert decimal number n``# to its binary representation``# stored as an array arr[]``def` `decBinary(arr, n):``    ``k ``=` `int``(math.log2(n))``    ``while` `(n > ``0``):``        ``arr[k] ``=` `n ``%` `2``        ``k ``=` `k ``-` `1``        ``n ``=` `n``/``/``2` `# Funtion to convert the number``# represented as a binary array``# arr[] its decimal equivalent``def` `binaryDec(arr, n):``    ``ans ``=` `0``    ``for` `i ``in` `range``(``0``, n):``        ``ans ``=` `ans ``+` `(arr[i] << (n ``-` `i ``-` `1``))``    ``return` `ans` `# Function to concatenate the binary``# numbers and return the decimal result``def` `concat(m, n):` `    ``# Number of bits in both the numbers``    ``k ``=` `int``(math.log2(m)) ``+` `1``    ``l ``=` `int``(math.log2(n)) ``+` `1` `    ``# Convert the bits in both the gers``    ``# to the arrays a[] and b[]``    ``a ``=` `[``0` `for` `i ``in` `range``(``0``, k)]``    ``b ``=` `[``0` `for` `i ``in` `range``(``0``, l)]` `    ``# c[] will be the binary array``    ``# for the result``    ``c ``=` `[``0` `for` `i ``in` `range``(``0``, k ``+` `l)]``    ``decBinary(a, m);``    ``decBinary(b, n);` `    ``# Update the c[] array``    ``iin ``=` `0``    ``for` `i ``in` `range``(``0``, k):``        ``c[iin] ``=` `a[i]``        ``iin ``=` `iin ``+` `1``    ``for` `i ``in` `range``(``0``, l):``        ``c[iin] ``=` `b[i]``        ``iin ``=` `iin ``+` `1` `    ``# Return the decimal equivalent``    ``# of the result``    ``return` `(binaryDec(c, k ``+` `l))` `# Driver code``m ``=` `4``n ``=` `5` `print``(concat(m, n))` `# This code is contributed by Sanjit_Prasad`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{``    ` `    ``// Function to convert decimal number n``    ``// to its binary representation``    ``// stored as an array []arr``    ``static` `void` `decBinary(``int` `[]arr, ``int` `n)``    ``{``        ``int` `k = (``int``)(Math.Log(n) /``                      ``Math.Log(2));``        ` `        ``while` `(n > 0)``        ``{``            ``arr[k--] = n % 2;``            ``n /= 2;``        ``}``    ``}``    ` `    ``// Funtion to convert the number``    ``// represented as a binary array``    ``// []arr into its decimal equivalent``    ``static` `int` `binaryDec(``int` `[]arr, ``int` `n)``    ``{``        ``int` `ans = 0;``        ``for` `(``int` `i = 0; i < n; i++)``            ``ans += arr[i] << (n - i - 1);``        ``return` `ans;``    ``}``    ` `    ``// Function to concatenate the binary``    ``// numbers and return the decimal result``    ``static` `int` `concat(``int` `m, ``int` `n)``    ``{``    ` `        ``// Number of bits in both the numbers``        ``int` `k = (``int``)(Math.Log(m) /``                      ``Math.Log(2)) + 1;``        ``int` `l = (``int``)(Math.Log(n) /``                      ``Math.Log(2)) + 1;``    ` `        ``// Convert the bits in both the integers``        ``// to the arrays []a and []b``        ``int` `[]a = ``new` `int``[k];``        ``int` `[]b = ``new` `int``[l];``    ` `        ``// c[] will be the binary array``        ``// for the result``        ``int` `[]c = ``new` `int``[k + l];``        ``decBinary(a, m);``        ``decBinary(b, n);``    ` `        ``// Update the c[] array``        ``int` `iN = 0;``        ``for` `(``int` `i = 0; i < k; i++)``            ``c[iN++] = a[i];``        ``for` `(``int` `i = 0; i < l; i++)``            ``c[iN++] = b[i];``    ` `        ``// Return the decimal equivalent``        ``// of the result``        ``return` `(binaryDec(c, k + l));``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int` `m = 4, n = 5;``    ` `        ``Console.WriteLine(concat(m, n));``    ``}``}` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``
Output
`37`

The time complexity of above solution is O(log(m) + log(n)).

We can improve the time complexity for above problem to O(log(n)) by using binary shift operators.

Better Approach

We will binary shift the number M to left by the number of bits in n.

For example:

M=4, N=5

bin(N) = 101 which has binary representation three.

We will left binary shift M by 3 and then add N.

M<<3 + N = 37.

As binary shift operators take constant time so second step is done in constant time and overall time complexity is O(log(N)).

Below is the implementation of above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Utility function to calculate binary``// length of a number.``int` `getBinaryLength(``int` `n)``{``    ``int` `length = 0;``    ``while` `(n > 0) {``        ``length += 1;``        ``n /= 2;``    ``}``    ``return` `length;``}` `// Function to concatenate the binary``// numbers and return the decimal result``int` `concat(``int` `m, ``int` `n)``{``    ``// find binary length of n``    ``int` `length = getBinaryLength(n);` `    ``// left binary shift m and then add n``    ``return` `(m << length) + n;``}` `// Driver code``int` `main()``{``    ``int` `m = 4, n = 5;` `    ``cout << concat(m, n);` `    ``return` `0;``}` `// This code is contributed by Vivek Moar`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG{``    ` `// Utility function to calculate binary``// length of a number.``public` `static` `int` `getBinaryLength(``int` `n)``{``    ``int` `length = ``0``;``    ``while` `(n > ``0``)``    ``{``        ``length += ``1``;``        ``n /= ``2``;``    ``}``    ``return` `length;``}`` ` `// Function to concatenate the binary``// numbers and return the decimal result``public` `static` `int` `concat(``int` `m, ``int` `n)``{``    ` `    ``// Find binary length of n``    ``int` `length = getBinaryLength(n);``    ` `    ``// left binary shift m and then add n``    ``return` `(m << length) + n;``}` `// Driver code``public` `static` `void` `main(String[] args) ``throws` `Exception``{``    ``int` `m = ``4``, n = ``5``;` `    ``System.out.println(concat(m, n));``}``}` `// This code is contributed by divyesh072019`

## Python3

 `# Python3 implementation of the approach` `# Utility function to calculate binary``# length of a number.`  `def` `getBinaryLength(n):``    ``length ``=` `0``    ``while``(n > ``0``):``        ``length ``+``=` `1``        ``n ``/``/``=` `2``    ``return` `length` `# Function to concatenate the binary``# numbers and return the decimal result`  `def` `concat(m, n):``    ``# find binary length of n``    ``length ``=` `getBinaryLength(n)` `    ``# left binary shift m and then add n``    ``return` `(m << length) ``+` `n` `# Driver code`  `m, n ``=` `4``, ``5` `print``(concat(m, n))` `# This code is contributed by Vivek Moar`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG{``    ` `// Utility function to calculate binary``// length of a number.``static` `int` `getBinaryLength(``int` `n)``{``    ``int` `length = 0;``    ` `    ``while` `(n > 0)``    ``{``        ``length += 1;``        ``n /= 2;``    ``}``    ``return` `length;``}``  ` `// Function to concatenate the binary``// numbers and return the decimal result``static` `int` `concat(``int` `m, ``int` `n)``{``    ` `    ``// Find binary length of n``    ``int` `length = getBinaryLength(n);``     ` `    ``// left binary shift m and then add n``    ``return` `(m << length) + n;``}` `// Driver code``static` `void` `Main()``{``    ``int` `m = 4, n = 5;``    ` `    ``Console.WriteLine(concat(m, n));``}``}` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``
Output
`37`

Time Complexity: O(log(n)).

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up