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

• Difficulty Level : Expert
• Last Updated : 17 Jan, 2022

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;``    ``}``}` `// Function 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``;``        ``}``    ``}``    ` `    ``// Function 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` `# Function 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;``        ``}``    ``}``    ` `    ``// Function 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)).

My Personal Notes arrow_drop_up