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

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

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

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

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.