Nos dan dos números n y m, y posiciones de dos bits, i y j. Inserte bits de m en n comenzando desde j hasta i. Podemos suponer que los bits j a i tienen suficiente espacio para que quepa todo m. Es decir, si m = 10011, puede suponer que hay al menos 5 bits entre j e i. Por ejemplo, no tendría j = 3 e i = 2, porque m no podría caber completamente entre el bit 3 y el bit 2.
Ejemplos:
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
Algoritmo:
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.
La parte más complicada es el Paso 1. ¿Cómo borramos los bits en n? Podemos hacer esto con una máscara. Esta máscara tendrá todos 1, excepto 0 en los bits j a i. Creamos esta máscara creando primero la mitad izquierda de la máscara y luego la mitad derecha.
A continuación se muestra la implementación del enfoque anterior.
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>
Producción:
1100 // in Binary (10001001100)2
Este artículo es una contribución del Sr. Somesh Awasthi . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a contribuido@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA