# Set bits in N equals to M in the given range.

You are given two 32-bit numbers, N and M, and two bit positions, i and j. Write a method to set all bits between i and j in N equal to M (e.g., M becomes a substring of N located at i and starting at j).
Examples :

```Input : N = 1, M = 2, i = 2, j = 4
Output: 9
N = 00000001(Considering 8 bits only)
M = 10 (Binary of 2) For more indexes,
Now set 3 bits from ith index to j in
the N as in the M.
Bits:-    0 0 0 (0  1  0) 0 1 = 9
Indexes:- 7 6 5  4  3  2  1 0
From index 2 to 4, bits are set according
to the M.```

A simple solution is to traverse all bits in N from 0 to 31 and set the bits equals to M in the range from i to j.
An efficient solution is to do following steps.

1. Set all the bits after j in a number.
2. Set all the bits before i in a number.
3. Then perform Bitwise Or on both then we get the number with all the bits set except from i to j.
4. Perform Bitwise And with the given N as to set the bits according to the N.
5. Then shift M into the correct position i.e. in the range of i to j.
6. And at the last perform Bitwise Or on (Shifted M and the N modified in 4th step).
7. The result will be N with M as substring from ith to jth bits

## C++

 `// C++ program for above implementation ``#include ``using` `namespace` `std; `` ` `// Function to set the bits ``int` `setBits(``int` `n, ``int` `m, ``int` `i, ``int` `j) ``{ ``    ``// number with all 1's ``    ``int` `allOnes = ~0; `` ` `    ``// Set all the bits in the left of j ``    ``int` `left = allOnes << (j + 1); `` ` `    ``// Set all the bits in the right of j ``    ``int` `right = ((1 << i) - 1); `` ` `    ``// Do Bitwise OR to get all the bits  ``    ``// set except in the range from i to j ``    ``int` `mask = left | right; `` ` `    ``// clear bits j through i ``    ``int` `masked_n = n & mask; `` ` `    ``// move m into the correct position ``    ``int` `m_shifted = m << i; `` ` `    ``// return the Bitwise OR of masked_n  ``    ``// and shifted_m ``    ``return` `(masked_n | m_shifted); ``} `` ` `// Drivers program ``int` `main() ``{ ``    ``int` `n = 2, m = 4; ``    ``int` `i = 2, j = 4; ``    ``cout << setBits(n, m, i, j); ``    ``return` `0; ``} `

## Java

 `// Java Program  ``public` `class` `GFG ``{ ``    ``// Function to set the bits ``    ``static` `int` `setBits(``int` `n, ``int` `m, ``int`  `i, ``int` `j) ``    ``{ ``         ` `        ``// number with all 1's ``        ``int`  `allOnes = ~``0``; ``         ` `        ``// Set all the bits in the left of j ``        ``int` `left = allOnes << (j + ``1``); ``         ` `        ``// Set all the bits in the right of j ``        ``int` `right = ((``1` `<< i) - ``1``); ``         ` `        ``// Do Bitwise OR to get all the bits  ``        ``// set except in the range from i to j ``        ``int` `mask = left | right; ``         ` `        ``// clear bits j through i ``        ``int` `masked_n = n & mask; ``         ` `        ``// move m into the correct position ``        ``int` `m_shifted = m << i; ``         ` `        ``// return the Bitwise OR of masked_n  ``        ``// and shifted_m ``        ``return` `(masked_n | m_shifted); ``    ``} ``     ` `    ``// Driver Program to test above function ``    ``public` `static` `void` `main(String[] args)  ``    ``{ ``        ``int` `n = ``2``, m = ``4``; ``        ``int` `i = ``2``, j = ``4``; ``        ``System.out.println(setBits(n, m, i, j)); ``    ``} ``} ``// This code is contributed by Sumit Ghosh `

## Python3

 `# Python program for above implementation `` ` `# Function to set the bits ``def` `setBits(n, m, i, j): `` ` `    ``# number with all 1's ``    ``allOnes ``=` `not` `0``  ` `    ``# Set all the bits in the left of j ``    ``left ``=` `allOnes << (j ``+` `1``) ``  ` `    ``# Set all the bits in the right of j ``    ``right ``=` `((``1` `<< i) ``-` `1``) ``  ` `    ``# Do Bitwise OR to get all the bits  ``    ``# set except in the range from i to j ``    ``mask ``=` `left | right ``  ` `    ``# clear bits j through i ``    ``masked_n ``=` `n & mask ``  ` `    ``# move m into the correct position ``    ``m_shifted ``=` `m << i ``  ` `    ``# return the Bitwise OR of masked_n  ``    ``# and shifted_m ``    ``return` `(masked_n | m_shifted) ``  ` `# Drivers program ``n, m ``=` `2``, ``4``i, j ``=` `2``, ``4``print``(setBits(n, m, i, j)) `` ` `# This code is submitted by Sachin Bisht `

## C#

 `// C# Program for above implementation ``using` `System; `` ` `public` `class` `GFG { ``     ` `    ``// Function to set the bits ``    ``static` `int` `setBits(``int` `n, ``int` `m, ``int`  `i, ``int` `j) ``    ``{ ``          ` `        ``// number with all 1's ``        ``int`  `allOnes = ~0; ``          ` `        ``// Set all the bits in the left of j ``        ``int` `left = allOnes << (j + 1); ``          ` `        ``// Set all the bits in the right of j ``        ``int` `right = ((1 << i) - 1); ``          ` `        ``// Do Bitwise OR to get all the bits  ``        ``// set except in the range from i to j ``        ``int` `mask = left | right; ``          ` `        ``// clear bits j through i ``        ``int` `masked_n = n & mask; ``          ` `        ``// move m into the correct position ``        ``int` `m_shifted = m << i; ``          ` `        ``// return the Bitwise OR of masked_n  ``        ``// and shifted_m ``        ``return` `(masked_n | m_shifted); ``    ``} ``      ` `    ``// Driver Program to test above function ``    ``public` `static` `void` `Main()  ``    ``{ ``        ``int` `n = 2, m = 4; ``        ``int` `i = 2, j = 4; ``         ` `        ``Console.WriteLine(setBits(n, m, i, j)); ``    ``} ``} `` ` `// This code is contributed by Anant Agarwal. `

## PHP

 ` `

## Javascript

 ``

Output :

`18`

Time Complexity: O(1)

Auxiliary Space: O(1)
Reference:
https://www.careercup.com/question?id=8863294

Previous
Next