Open In App

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

Improve
Improve
Like Article
Like
Save
Share
Report

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




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




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




# 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




<?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
?>


Javascript




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


Output

1100

Time Complexity: O(1)
Auxiliary Space: O(1)

This article is contributed by Mr. Somesh Awasthi.

 



Last Updated : 15 Nov, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads