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
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++ program for implementation of updateBits() #include <bits/stdc++.h> 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 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));
}
} |
# 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# 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 // PHP program for implementation // of updateBits() // Function to updateBits // M insert to N. function 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
// Clear bits j through i.
$n_cleared = $n & $mask ;
// Move m into correct position.
$m_shifted = $m << $i ;
// OR them, and we're done!
return ( $n_cleared | $m_shifted );
} // Driver Code // in Binary N= 10000000000 $n = 1024;
// in Binary M= 10011 $m = 19;
$i = 2;
$j = 6;
echo updateBits( $n , $m , $i , $j );
// This code is contributed by Ajit ?> |
<script> // JavaScript program for implementation of updateBits() // Function to updateBits M insert to N.
function 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. */
let allOnes = ~0; // will equal sequence of all ls
// ls before position j, then 0s. left = 11100000
let left= allOnes << (j + 1);
// l's after position i. right = 00000011
let right = ((1 << i) - 1);
// All ls, except for 0s between i and j. mask 11100011
let mask = left | right;
/* Clear bits j through i then put min there */
// Clear bits j through i.
let n_cleared = n & mask;
// Move m into correct position.
let m_shifted = m << i;
// OR them, and we're done!
return (n_cleared | m_shifted);
}
// in Binary N= 10000000000
let n = 1024;
// in Binary M= 10011
let m = 19;
let i = 2, j = 6;
document.write(updateBits(n,m,i,j));
// This code is contributed by sravan </script> |
1100
Time Complexity: O(1)
Auxiliary Space: O(1)
This article is contributed by Mr. Somesh Awasthi.