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

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 their 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 <bits/stdc++.h>
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

<script>
    // Javascript implementation of the approach

    // Function to convert decimal number n
    // to its binary representation
    // stored as an array []arr
    function decBinary(arr, n)
    {
        let k = parseInt(Math.log(n) / Math.log(2), 10);

        while (n > 0)
        {
            arr[k--] = n % 2;
            n = parseInt(n / 2, 10);
        }
    }

    // Function to convert the number
    // represented as a binary array
    // []arr into its decimal equivalent
    function binaryDec(arr, n)
    {
        let ans = 0;
        for (let i = 0; i < n; i++)
            ans += arr[i] << (n - i - 1);
        return ans;
    }

    // Function to concatenate the binary
    // numbers and return the decimal result
    function concat(m, n)
    {

        // Number of bits in both the numbers
        let k = parseInt(Math.log(m) / Math.log(2), 10) + 1;
        let l = parseInt(Math.log(n) / Math.log(2), 10) + 1;

        // Convert the bits in both the integers
        // to the arrays []a and []b
        let a = new Array(k);
        let b = new Array(l);

        // c[] will be the binary array
        // for the result
        let c = new Array(k + l);
        decBinary(a, m);
        decBinary(b, n);

        // Update the c[] array
        let iN = 0;
        for (let i = 0; i < k; i++)
            c[iN++] = a[i];
        for (let i = 0; i < l; i++)
            c[iN++] = b[i];

        // Return the decimal equivalent
        // of the result
        return (binaryDec(c, k + l));
    }

    let m = 4, n = 5;

    document.write(concat(m, n));

    // This code is contributed by rameshtravel07.
</script>

Output

37

Time Complexity: O(log(m) + log(n)), We can improve the time complexity for the above problem to O(log(n)) by using binary shift operators.
Auxiliary Space: O(1) 

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

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 <bits/stdc++.h>
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

<script>

    // Javascript implementation of the approach

    // Utility function to calculate binary
    // length of a number.
    function getBinaryLength(n)
    {
        let length = 0;

        while (n > 0)
        {
            length += 1;
            n = parseInt(n / 2, 10);
        }
        return length;
    }

    // Function to concatenate the binary
    // numbers and return the decimal result
    function concat(m, n)
    {

        // Find binary length of n
        let length = getBinaryLength(n);

        // left binary shift m and then add n
        return (m << length) + n;
    }

    let m = 4, n = 5;

    document.write(concat(m, n));

</script>

Output

37

Time Complexity: O(log(n)).
Auxiliary Space: O(1)