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

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

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

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

## PHP

`<?php ` `// PHP program to insert 32-bit number ` `// M into N using bit magic ` ` ` `// print binary representation of n ` `function` `bin(` `$n` `) ` `{ ` ` ` `if` `(` `$n` `> 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.