# Inserting m into n such that m starts at bit j and ends at bit i.

We are given two numbers n and m, and two-bit positions, i and j. Insert bits of m into n starting from j to i. We can assume that the bits j through i have enough space to fit all of m. That is, if m = 10011, you can assume that there are at least 5 bits between j and i. You would not, for example, have j = 3 and i = 2, because m could not fully fit between bit 3 and bit 2.

Examples :

```Input : n = 1024
m = 19
i = 2
j = 6;
Output : n = 1100
Binary representations of input numbers
m in binary is (10011)2
n in binary is (10000000000)2
Binary representations of output number
(10000000000)2

Input : n = 5
m = 3
i = 1
j = 2
Output : 7
```

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

Algorithm :

```1. Clear the bits j through i in n

2. Shift m so that it lines up with bits j through i

3. Return Bitwise AND of m and n.
```

The trickiest part is Step 1. How do we clear the bits in n? We can do this with a mask. This mask will have all 1s, except for 0s in the bits j through i. We create this mask by creating the left half of the mask first, and then the right half.

Following is the implementation of the above approach.

## C++

 `// C++ program for implementation of updateBits() ` `#include ` `using` `namespace` `std; ` ` `  `// Function to updateBits M insert to N. ` `int` `updateBits(``int` `n, ``int` `m, ``int` `i, ``int` `j) ` `{ ` `    ``/* Create a mask to clear bits i through j ` `      ``in n. EXAMPLE: i = 2, j = 4. Result ` `      ``should be 11100011. For simplicity, we'll ` `      ``use just 8 bits for the example. */` ` `  `    ``int` `allOnes = ~0; ``// will equal sequence of all ls ` ` `  `    ``// ls before position j, then 0s. left = 11100000 ` `    ``int` `left= allOnes << (j + 1); ` ` `  `    ``// l's after position i. right = 00000011 ` `    ``int` `right = ((1 << i) - 1); ` ` `  `    ``// All ls, except for 0s between i and j. mask 11100011 ` `    ``int` `mask = left | right; ` ` `  `    ``/* Clear bits j through i then put min there */` `    ``int` `n_cleared = n & mask; ``// Clear bits j through i. ` `    ``int` `m_shifted = m << i;   ``// Move m into correct position. ` ` `  `    ``return` `(n_cleared | m_shifted); ``// OR them, and we're done! ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `n = 1024; ``// in Binary N= 10000000000 ` `    ``int` `m = 19;   ``// in Binary M= 10011 ` `    ``int` `i = 2, j = 6; ` ` `  `    ``cout << updateBits(n,m,i,j); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program for implementation of updateBits() ` ` `  `class` `UpdateBits  ` `{ ` `    ``// Function to updateBits M insert to N. ` `    ``static` `int` `updateBits(``int` `n, ``int` `m, ``int` `i, ``int` `j) ` `    ``{ ` `        ``/* Create a mask to clear bits i through j ` `          ``in n. EXAMPLE: i = 2, j = 4. Result ` `          ``should be 11100011. For simplicity, we'll ` `          ``use just 8 bits for the example. */` `      `  `        ``int` `allOnes = ~``0``; ``// will equal sequence of all ls ` `      `  `        ``// ls before position j, then 0s. left = 11100000 ` `        ``int` `left= allOnes << (j + ``1``); ` `      `  `        ``// l's after position i. right = 00000011 ` `        ``int` `right = ((``1` `<< i) - ``1``); ` `      `  `        ``// All ls, except for 0s between i and j. mask 11100011 ` `        ``int` `mask = left | right; ` `      `  `        ``/* Clear bits j through i then put min there */` `        ``// Clear bits j through i. ` `        ``int` `n_cleared = n & mask;  ` `        ``// Move m into correct position. ` `        ``int` `m_shifted = m << i;   ` `         `  `        ``// OR them, and we're done! ` `        ``return` `(n_cleared | m_shifted);  ` `    ``} ` `     `  `    ``public` `static` `void` `main (String[] args)  ` `    ``{ ` `        ``// in Binary N= 10000000000 ` `        ``int` `n = ``1024``;  ` `         `  `        ``// in Binary M= 10011 ` `        ``int` `m = ``19``;    ` `         `  `        ``int` `i = ``2``, j = ``6``; ` `      `  `        ``System.out.println(updateBits(n,m,i,j)); ` `    ``} ` `} `

/div>

## Python3

 `# Python3 program for implementation ` `# of updateBits() ` ` `  `# Function to updateBits M insert to N. ` `def` `updateBits(n, m, i, j): ` ` `  `    ``# Create a mask to clear bits i through  ` `    ``# j in n. EXAMPLE: i = 2, j = 4. Result ` `    ``# should be 11100011. For simplicity,  ` `    ``# we'll use just 8 bits for the example. ` ` `  `    ``# will equal sequence of all ls ` `    ``allOnes ``=` `~``0`  ` `  `    ``# ls before position j, ` `    ``# then 0s. left = 11100000 ` `    ``left ``=` `allOnes << (j ``+` `1``) ` ` `  `    ``# l's after position i. right = 00000011 ` `    ``right ``=` `((``1` `<< i) ``-` `1``) ` ` `  `    ``# All ls, except for 0s between ` `    ``# i and j. mask 11100011 ` `    ``mask ``=` `left | right ` ` `  `    ``# Clear bits j through i then put min there  ` `    ``n_cleared ``=` `n & mask ` `     `  `    ``# Move m into correct position. ` `    ``m_shifted ``=` `m << i  ` ` `  `    ``return` `(n_cleared | m_shifted) ` ` `  ` `  `# Driver Code ` `n ``=` `1024` `# in Binary N = 10000000000 ` `m ``=` `19`   `# in Binary M = 10011 ` `i ``=` `2``; j ``=` `6` `print``(updateBits(n, m, i, j)) ` ` `  `# This code is contributed by Anant Agarwal. `

## C#

 `// C# program for implementation of  ` `// updateBits() ` `using` `System; ` ` `  `class` `GFG { ` `     `  `    ``// Function to updateBits M  ` `    ``// insert to N. ` `    ``static` `int` `updateBits(``int` `n, ``int` `m,  ` `                           ``int` `i, ``int` `j) ` `    ``{ ` `         `  `        ``/* Create a mask to clear bits i ` `          ``through j in n. EXAMPLE: i = 2, ` `          ``j = 4. Result should be 11100011. ` `          ``For simplicity, we'll use just 8 ` `          ``bits for the example. */` `       `  `        ``// will equal sequence of all ls ` `        ``int` `allOnes = ~0;  ` `       `  `        ``// ls before position j, then 0s.  ` `        ``// left = 11100000 ` `        ``int` `left= allOnes << (j + 1); ` `       `  `        ``// l's after position i.  ` `        ``// right = 00000011 ` `        ``int` `right = ((1 << i) - 1); ` `       `  `        ``// All ls, except for 0s between i  ` `        ``// and j. mask 11100011 ` `        ``int` `mask = left | right; ` `       `  `        ``/* Clear bits j through i then put  ` `        ``min there */` `        ``// Clear bits j through i. ` `        ``int` `n_cleared = n & mask;  ` `         `  `        ``// Move m into correct position. ` `        ``int` `m_shifted = m << i;   ` `          `  `        ``// OR them, and we're done! ` `        ``return` `(n_cleared | m_shifted);  ` `    ``} ` `      `  `    ``public` `static` `void` `Main()  ` `    ``{ ` `         `  `        ``// in Binary N= 10000000000 ` `        ``int` `n = 1024;  ` `          `  `        ``// in Binary M= 10011 ` `        ``int` `m = 19;    ` `        ``int` `i = 2, j = 6; ` `       `  `        ``Console.WriteLine(updateBits(n, m, i, j)); ` `    ``} ` `} ` ` `  `//This code is contributed by Anant Agarwal. `

## PHP

 ` `

Output :

``` 1100  // in Binary (10001001100)2
```

## tags:

Bit Magic Bit Magic