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

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)
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 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
```

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++ 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; ` ` `  `    ``// Shiftng 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 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; ` ` `  `    ``// Shiftng 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. `

 `# 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 ` ` `  `    ``# Shiftng 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# 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; ` ` `  `    ``// Shiftng 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 `

 ` 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``; ` ` `  `    ``// Shiftng 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 ` `?> `

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

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.

Article Tags :
Practice Tags :