Siguiente entero mayor que tiene un número más de bits establecidos

Dado un entero positivo ‘n’ que tiene ‘x’ número de bits establecidos en su representación binaria. El problema es encontrar el siguiente entero mayor (el menor entero mayor que n), que tenga (x+1) el número de bits establecidos en su representación binaria.
Ejemplos: 
 

Input : 10
Output : 11
(10)10 = (1010)2
is having 2 set bits.

(11)10 = (1011)2
is having 3 set bits and is the next greater.

Input : 39
Output : 47

Enfoque: Los siguientes son los pasos: 

1. Encuentre la posición del bit no establecido más a la derecha (considerando el último bit en la posición 0, el penúltimo bit en la posición 1 y así sucesivamente) en la representación binaria de n .
2. Sea la posición representada por pos .
3. Establezca el bit en la posición pos . Consulte esta publicación.
4. Si no hay bits no configurados en la representación binaria, realice un desplazamiento a la izquierda bit a bit de 1 en el número dado y luego agréguele 1.

¿Cómo obtener la posición del bit no configurado más a la derecha? 

1. Realice bit a bit no en el número dado (operación equivalente al complemento de 1). Sea num = ~n.
2. Obtener la posición del bit establecido más a la derecha de num .

// C++ implementation to find the next greater integer
// with one more number of set bits
#include <bits/stdc++.h>
 
using namespace std;
 
// function to find the position of rightmost
// set bit. Returns -1 if there are no set bits
int getFirstSetBitPos(int n)
{
    return (log2(n&-n)+1) - 1;
}
 
// function to find the next greater integer
int nextGreaterWithOneMoreSetBit(int n)
{
    // position of rightmost unset bit of n
    // by passing ~n as argument
    int pos = getFirstSetBitPos(~n);
     
    // if n consists of unset bits, then
    // set the rightmost unset bit
    if (pos > -1)
        return (1 << pos) | n;
         
    //n does not consists of unset bits   
    return ((n << 1) + 1);   
}
 
// Driver program to test above
int main()
{
    int n = 10;
    cout << "Next greater integer = "
          << nextGreaterWithOneMoreSetBit(n);
    return 0;
}

// Java implementation to find the next greater integer
// with one more number of set bits
class GFG {
     
    // function to find the position of rightmost
    // set bit. Returns -1 if there are no set bits
    static int getFirstSetBitPos(int n)
    {
        return ((int)(Math.log(n & -n) / Math.log(2)) + 1) - 1;
    }
 
    // function to find the next greater integer
    static int nextGreaterWithOneMoreSetBit(int n)
    {
         
        // position of rightmost unset bit of n
        // by passing ~n as argument
        int pos = getFirstSetBitPos(~n);
 
        // if n consists of unset bits, then
        // set the rightmost unset bit
        if (pos > -1)
            return (1 << pos) | n;
 
        // n does not consists of unset bits
        return ((n << 1) + 1);
    }
     
    // Driver code
    public static void main(String[] args)
    {
        int n = 10;
        System.out.print("Next greater integer = "
                + nextGreaterWithOneMoreSetBit(n));
    }
}
 
// This code is contributed by Anant Agarwal.

# Python3 implementation to find
# the next greater integer with
# one more number of set bits
import math
 
# Function to find the position
# of rightmost set bit. Returns -1
# if there are no set bits
def getFirstSetBitPos(n):
 
    return ((int)(math.log(n & -n) /
                  math.log(2)) + 1) - 1
 
# Function to find the next greater integer
def nextGreaterWithOneMoreSetBit(n):
 
    # position of rightmost unset bit of
    # n by passing ~n as argument
    pos = getFirstSetBitPos(~n)
     
    # if n consists of unset bits, then
    # set the rightmost unset bit
    if (pos > -1):
        return (1 << pos) | n
         
    # n does not consists of unset bits
    return ((n << 1) + 1)
 
# Driver code
n = 10
print("Next greater integer = ",
       nextGreaterWithOneMoreSetBit(n))
        
# This code is contributed by Anant Agarwal.

// C# implementation to find the next greater
// integer with one more number of set bits
using System;
 
class GFG {
     
    // function to find the position of rightmost
    // set bit. Returns -1 if there are no set bits
    static int getFirstSetBitPos(int n)
    {
        return ((int)(Math.Log(n & -n) / Math.Log(2))
                                            + 1) - 1;
    }
      
    // function to find the next greater integer
    static int nextGreaterWithOneMoreSetBit(int n)
    {
         
        // position of rightmost unset bit of n
        // by passing ~n as argument
        int pos = getFirstSetBitPos(~n);
          
        // if n consists of unset bits, then
        // set the rightmost unset bit
        if (pos > -1)
            return (1 << pos) | n;
              
        // n does not consists of unset bits   
        return ((n << 1) + 1);   
    }
     
    // Driver code
    public static void Main()
    {
        int n = 10;
         
        Console.Write("Next greater integer = "
              + nextGreaterWithOneMoreSetBit(n));
    }
}
 
// This code is contributed by Anant Agarwal.

<?php
// PHP implementation to find the
// next greater integer with
// one more number of set bits
 
// function to find the position
// of rightmost set bit. Returns
// -1 if there are no set bits
 
function getFirstSetBitPos($n)
{
    return (log($n & -$n + 1)) - 1;
}
 
// function to find the
// next greater integer
 
function nextGreaterWithOneMoreSetBit($n)
{
    // position of rightmost unset bit of n
    // by passing ~n as argument
     
    $pos = getFirstSetBitPos(~$n);
     
    // if n consists of unset bits, then
    // set the rightmost unset bit
    if ($pos > -1)
        return (1 << $pos) | $n;
         
    //n does not consists of unset bits
    return (($n << 1) + 1);
}
 
// Driver Code
$n = 10;
echo "Next greater integer = ",
    nextGreaterWithOneMoreSetBit($n);
 
// This code is contributed by Ajit
?>

<script>
 
// Javascript implementation to find the next greater integer
// with one more number of set bits
 
// function to find the position of rightmost
// set bit. Returns -1 if there are no set bits
function getFirstSetBitPos(n)
{
    return (parseInt(Math.log(n&-n)/Math.log(2))+1) - 1;
}
 
// function to find the next greater integer
function nextGreaterWithOneMoreSetBit(n)
{
    // position of rightmost unset bit of n
    // by passing ~n as argument
    var pos = getFirstSetBitPos(~n);
     
    // if n consists of unset bits, then
    // set the rightmost unset bit
    if (pos > -1)
        return (1 << pos) | n;
         
    //n does not consists of unset bits    
    return ((n << 1) + 1);    
}
 
// Driver program to test above
var n = 10;
document.write("Next greater integer = " + nextGreaterWithOneMoreSetBit(n));
     
</script>

Producción : 

Next greater integer = 11

Complejidad de tiempo: O(log(log N))
Espacio auxiliar: O(1)

Este artículo es una contribución de Ayush Jauhari . 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 contribuir@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.