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.
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:
N = 1201(10010110001) M = 8(1000) After inserting M into N from 3 to 6 N = 1217(10011000001)
- Inserting m into n such that m starts at bit j and ends at bit i.
- Alternate XOR operations on sorted array
- Minimum Bitwise OR operations to make any two array elements equal
- Count total set bits in all numbers from 1 to n | Set 2
- Longest Subarray having strictly positive XOR
- Number formed by the rightmost set bit in N
- Count number of set bits in a range using bitset
- Find a number containing N - 1 set bits at even positions from the right
- Find XOR of numbers from the range [L, R]
- Count number of common elements between two arrays by using Bitset and Bitwise operation
- Sum of Bitwise OR of all pairs in a given array
- Maximum subset sum such that no two elements in set have same digit in them
- Count pairs of elements such that number of set bits in their AND is B[i]
- Number of 0s and 1s at prime positions in the given array
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to firstname.lastname@example.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.