# Inserting M into N such that m starts at bit j and ends at bit i | Set-2

• Last Updated : 31 Aug, 2021

Given two 32-bit numbers, N and M, and two-bit positions, i and j. Write a method to insert M into N such that M starts at bit j and ends at bit i. You can assume that the bits j through i have enough space to fit all of M. Assuming index start from 0.
Examples:

```a)  N = 1024 (10000000000),
M = 19 (10011),
i = 2, j = 6
Output : 1100 (10001001100)
b)  N = 1201 (10010110001)
M = 8 (1000)
i = 3, j = 6
Output: 1217 (10011000001)```

This problem has been already discussed in the previous post. In this post, a different approach is discussed.
Approach: The idea is very straightforward, following is the stepwise procedure –

• Capture all the bits before i in N, that is from i-1 to 0.
• We donâ€™t want to alter those bits so we will capture them and use later
• Clear all bits from j to 0
• Insert M into N at position j to i
• Insert captured bits at there respective position ie. from i-1 to 0

Let’s try to solve example b for a clear explanation of the procedure.

Capturing bits i-1 to 0 in N:
Create a mask whose i-1 to 0 bits are 1 and rest are 0. Shift 1 to i position in left and subtract 1 from this to get a bit mask having i-1 to 0 bits set.

`capture_mask = ( 1 << i ) - 1  `

So for example b, mask will be –

```capture_mask = ( 1 << 3 ) - 1
Now capture_mask = 1(001)```

Now AND this mask with N, i-1 to 0 bits will remain same while rest bits become 0. Thus we are left with i-1 to 0 bits only.

`captured_bits = N & capture_mask`

for example b, captured bits will be –

```captured_bits = N & capture_mask
Now capture_mask = 1 (001)```

Clearing bits from j to 0 in N:
Since bits have been captured, clear the bits j to 0 without loosing bits i-1 to 0. Create a mask whose j to 0 bits are 0 while the rest are 1. Create such mask by shifting -1 to j+1 position in left.

`clear_mask = -1 << ( j + 1 )`

Now to clear bits j to 0, AND mask with N.

`N  &= clear_mask `

For example b will be:

```N &= clear_mask
Now N = 1152 (10010000000)```

Inserting M in N:

Now because N has bits from j to 0 cleared, just fit in M into N and shift M i position to left to align the MSB of M with position j in N.

`M <<= i`

For example b-

```M <<= 3
Now M = 8 << 3 = 64 (1000000)```

Do a OR of M with N to insert M at desired position.

`N |= M`

For example b –

```N |= M
Now N = 1152 | 64 = 1216 (10011000000) ```

Inserting captured bits into N:

Till now M has been inserted into N. Now the only thing left is merging back the captured bits at position i-1 to 0. This can be simply done by OR of N and captured bits –

`N |= captured_bits`

For example b –

```N |= captured_bits
N = 1216 | 1 = 1217 (10011000001)```

So finally after insertion, the below bitset is obtained.

```N(before) = 1201 (10010110001)
N(after) = 1201 (10011000001)```

Below is the implementation of the above approach:

## C++

 `// C++ program to insert 32-bit number``// M into N using bit magic``#include ``using` `namespace` `std;` `// print binary representation of n``void` `bin(unsigned n)``{``    ``if` `(n > 1)``        ``bin(n / 2);``    ``printf``(``"%d"``, n % 2);``}` `// Insert m into n``int` `insertion(``int` `n, ``int` `m, ``int` `i, ``int` `j)``{``    ``int` `clear_mask = -1 << (j + 1);``    ``int` `capture_mask = (1 << i) - 1;` `    ``// Capturing bits from i-1 to 0``    ``int` `captured_bits = n & capture_mask;` `    ``// Clearing bits from j to 0``    ``n &= clear_mask;` `    ``// Shifting m to align with n``    ``m = m << i;` `    ``// Insert m into n``    ``n |= m;` `    ``// Insert captured bits``    ``n |= captured_bits;` `    ``return` `n;``}` `// Driver Code``int` `main()``{` `    ``// print original bitset``    ``int` `N = 1201, M = 8, i = 3, j = 6;``    ``cout << ``"N = "` `<< N << ``"("``;``    ``bin(N);``    ``cout << ``")"``         ``<< ``"\n"``;` `    ``// print original bitset``    ``cout << ``"M = "` `<< M << ``"("``;``    ``bin(M);``    ``cout << ``")"``         ``<< ``"\n"``;` `    ``// Call function to insert M to N``    ``N = insertion(N, M, i, j);``    ``cout << ``"After inserting M into N from 3 to 6"``         ``<< ``"\n"``;` `    ``// Print the inserted bitset``    ``cout << ``"N = "` `<< N << ``"("``;``    ``bin(N);``    ``cout << ``")"``         ``<< ``"\n"``;``    ``return` `0;``}`

## Java

 `// Java program to insert``// 32-bit number M into N``// using bit magic``import` `java.io.*;` `class` `GFG``{``    ` `// print binary``// representation of n``static` `void` `bin(``long` `n)``{``    ``if` `(n > ``1``)``        ``bin(n / ``2``);``    ``System.out.print(n % ``2``);``}` `// Insert m into n``static` `int` `insertion(``int` `n, ``int` `m,``                     ``int` `i, ``int` `j)``{``    ``int` `clear_mask = -``1` `<< (j + ``1``);``    ``int` `capture_mask = (``1` `<< i) - ``1``;` `    ``// Capturing bits from i-1 to 0``    ``int` `captured_bits = n & capture_mask;` `    ``// Clearing bits from j to 0``    ``n &= clear_mask;` `    ``// Shifting m to align with n``    ``m = m << i;` `    ``// Insert m into n``    ``n |= m;` `    ``// Insert captured bits``    ``n |= captured_bits;` `    ``return` `n;``}` `// Driver Code``public` `static` `void` `main (String[] args)``{``    ``// print original bitset``    ``int` `N = ``1201``, M = ``8``, i = ``3``, j = ``6``;``    ``System.out.print(``"N = "` `+ N + ``"("``);``    ``bin(N);``    ``System.out.println(``")"``);``    ` `    ``// print original bitset``    ``System.out.print(``"M = "` `+ M + ``"("``);``    ``bin(M);``    ``System.out.println(``")"``);``    ` `    ``// Call function to insert M to N``    ``N = insertion(N, M, i, j);``    ``System.out.println( ``"After inserting M "` `+``                        ``"into N from 3 to 6"``);``    ` `    ``// Print the inserted bitset``    ``System.out.print(``"N = "` `+ N + ``"("``);``    ``bin(N);``    ``System.out.println(``")"``);``}``}` `// This code is contributed``// by inder_verma.`

## Python3

 `# Python 3 program to insert 32-bit number``# M into N using bit magic` `# insert M into N``def` `insertion(n, m, i, j):` `    ``clear_mask ``=` `-``1` `<< (j ``+` `1``)``    ``capture_mask ``=` `(``1` `<< i) ``-` `1` `    ``# Capturing bits from i-1 to 0``    ``captured_bits ``=` `n & capture_mask` `    ``# Clearing bits from j to 0``    ``n &``=` `clear_mask` `    ``# Shifting m to align with n``    ``m ``=` `m << i` `    ``# Insert m into n``    ``n |``=` `m` `    ``# Insert captured bits``    ``n |``=` `captured_bits` `    ``return` `n` `# Driver``def` `main():``    ``N ``=` `1201``; M ``=` `8``; i ``=` `3``; j ``=` `6``    ``print``(``"N = {}({})"``.``format``(N, ``bin``(N)))``    ``print``(``"M = {}({})"``.``format``(M, ``bin``(M)))``    ``N ``=` `insertion(N, M, i, j)``    ``print``(``"***After inserting M into N***"``)``    ``print``(``"N = {}({})"``.``format``(N, ``bin``(N)))` `if` `__name__ ``=``=` `'__main__'``:``    ``main()`

## C#

 `// C# program to insert``// 32-bit number M into N``// using bit magic``using` `System;` `class` `GFG``{``    ` `// print binary``// representation of n``static` `void` `bin(``long` `n)``{``    ``if` `(n > 1)``        ``bin(n / 2);``    ``Console.Write(n % 2);``}` `// Insert m into n``static` `int` `insertion(``int` `n, ``int` `m,``                     ``int` `i, ``int` `j)``{``    ``int` `clear_mask = -1 << (j + 1);``    ``int` `capture_mask = (1 << i) - 1;` `    ``// Capturing bits from i-1 to 0``    ``int` `captured_bits = n & capture_mask;` `    ``// Clearing bits from j to 0``    ``n &= clear_mask;` `    ``// Shifting m to align with n``    ``m = m << i;` `    ``// Insert m into n``    ``n |= m;` `    ``// Insert captured bits``    ``n |= captured_bits;` `    ``return` `n;``}` `// Driver Code``static` `public` `void` `Main (String []args)``{``    ``// print original bitset``    ``int` `N = 1201, M = 8, i = 3, j = 6;``    ``Console.Write(``"N = "` `+ N + ``"("``);``    ``bin(N);``    ``Console.WriteLine(``")"``);``    ` `    ``// print original bitset``    ``Console.Write(``"M = "` `+ M + ``"("``);``    ``bin(M);``    ``Console.WriteLine(``")"``);``    ` `    ``// Call function to``    ``// insert M to N``    ``N = insertion(N, M, i, j);``    ``Console.WriteLine(``"After inserting M "` `+``                      ``"into N from 3 to 6"``);``    ` `    ``// Print the inserted bitset``    ``Console.Write(``"N = "` `+ N + ``"("``);``    ``bin(N);``    ``Console.WriteLine(``")"``);``}``}` `// This code is contributed``// by Arnab Kundu`

## PHP

 ` 1)``        ``bin(``\$n` `/ 2);``    ``echo` `\$n` `% 2;``}` `// Insert m into n``function` `insertion(``\$n``, ``\$m``, ``\$i``, ``\$j``)``{``    ``\$clear_mask` `= -1 << (``\$j` `+ 1);``    ``\$capture_mask` `= (1 << ``\$i``) - 1;` `    ``// Capturing bits from i-1 to 0``    ``\$captured_bits` `= ``\$n` `& ``\$capture_mask``;` `    ``// Clearing bits from j to 0``    ``\$n` `&= ``\$clear_mask``;` `    ``// Shifting m to align with n``    ``\$m` `= ``\$m` `<< ``\$i``;` `    ``// Insert m into n``    ``\$n` `|= ``\$m``;` `    ``// Insert captured bits``    ``\$n` `|= ``\$captured_bits``;` `    ``return` `\$n``;``}` `// Driver Code` `// print original bitset``\$N` `= 1201;``\$M` `= 8;``\$i` `= 3;``\$j` `= 6;``echo` `"N = "` `. ``\$N` `.``"("``;``bin(``\$N``);``echo` `")"` `.``"\n"``;` `// print original bitset``echo` `"M = "` `. ``\$M` `.``"("``;``bin(``\$M``);``echo` `")"``. ``"\n"``;` `// Call function to insert M to N``\$N` `= insertion(``\$N``, ``\$M``, ``\$i``, ``\$j``);``echo` `"After inserting M into N "` `.``              ``"from 3 to 6"` `.``"\n"``;` `// Print the inserted bitset``echo` `"N = "` `. ``\$N` `. ``"("``;``bin(``\$N``);``echo` `")"``. ``"\n"``;` `// This code is contributed``// by ChitraNayal``?>`

## Javascript

 ``
Output:
```N = 1201(10010110001)
M = 8(1000)
After inserting M into N from 3 to 6
N = 1217(10011000001)```

My Personal Notes arrow_drop_up