Mayor potencia de 2 menor o igual a Entero dado

Dado un número entero N , la tarea es encontrar la potencia más alta de 2 que sea menor o igual que N .

Ejemplos: 

Entrada: N = 9 
Salida: 8 
Explicación: 
La potencia más alta de 2 menos que 9 es 8.

Entrada: N = -20 
Salida: -32 
Explicación: 
La potencia más alta de 2 menos que -20 es -32.

Entrada: N = -84 
Salida: -128 
 

Enfoque: La idea es usar el logaritmo para resolver el problema anterior. Para cualquier número dado N, puede ser positivo o negativo. La siguiente tarea se puede realizar para cada caso:  

1. Si la entrada es positiva: se puede calcular el piso (log ₂ (N)) .
2. Si la entrada es negativa: se puede calcular ceil(log ₂ (N)) y se puede agregar un signo -ve al valor.

A continuación se muestra la implementación del enfoque anterior:  

// C++ implementation of the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the lowest power of 2 close to given
// positive number
int powOfPositive(int n)
{
    // Floor function is used to determine the value close
    // to the number
    int pos = floor(log2(n));
    return pow(2, pos);
}
 
// Function to return the lowest power of 2 close to given
// negative number
int powOfNegative(int n)
{
    // Ceil function is used for negative numbers as -1 >
    // -4. It would be opposite to positive numbers where 1 < 4
    int pos = ceil(log2(n));
    return (-1 * pow(2, pos));
}
 
// Function to find the highest power of 2
void highestPowerOf2(int n)
{
 
    // To check if the given number is positive or negative
    if (n > 0)
        cout << powOfPositive(n);
    else {
        // If the number is negative, then the ceil of the
        // positive number is calculated and negative sign
        // is added
        n = -n;
        cout << powOfNegative(n);
    }
}
 
// Driver code
int main()
{
    int n = -24;
    highestPowerOf2(n);
    return 0;
}
 
// This code is contributed by Sania Kumari Gupta

// C implementation of the above approach
#include <math.h>
#include <stdio.h>
 
// Function to return the lowest power of 2 close to given
// positive number
int powOfPositive(int n)
{
    // Floor function is used to determine the value close
    // to the number
    int pos = floor(log2(n));
    return pow(2, pos);
}
 
// Function to return the lowest power of 2 close to given
// negative number
int powOfNegative(int n)
{
    // Ceil function is used for negative numbers as -1 >
    // -4. It would be opposite to positive numbers where 1 < 4
    int pos = ceil(log2(n));
    return (-1 * pow(2, pos));
}
 
// Function to find the highest power of 2
void highestPowerOf2(int n)
{
 
    // To check if the given number is positive or negative
    if (n > 0)
        printf("%d", powOfPositive(n));
    else {
        // If the number is negative, then the ceil of the
        // positive number is calculated and negative sign
        // is added
        n = -n;
        printf("%d", powOfNegative(n));
    }
}
 
// Driver code
int main()
{
    int n = -24;
    highestPowerOf2(n);
    return 0;
}
 
// This code is contributed by Sania Kumari Gupta

// Java implementation of the above approach
class GFG
{
     
    // Function to return the lowest power
    // of 2 close to given positive number
    static int powOfPositive(int n)
    {
        // Floor function is used to determine
        // the value close to the number
        int pos = (int)Math.floor((Math.log(n)/Math.log(2)));
        return (int)Math.pow(2, pos);
    }
     
    // Function to return the lowest power
    // of 2 close to given negative number
    static int powOfNegative(int n)
    {
        // Ceil function is used for negative numbers
        // as -1 > -4. It would be opposite
        // to positive numbers where 1 < 4
        int pos = (int)Math.ceil((Math.log(n)/Math.log(2)));
        return (int)(-1 * Math.pow(2, pos));
    }
     
    // Function to find the highest power of 2
    static void highestPowerOf2(int n)
    {
     
        // To check if the given number
        // is positive or negative
        if (n > 0)
        {
            System.out.println(powOfPositive(n));
        }
        else
        {
            // If the number is negative,
            // then the ceil of the positive number
            // is calculated and
            // negative sign is added
            n = -n;
            System.out.println(powOfNegative(n));
        }
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int n = -24;
        highestPowerOf2(n);
    }
}
 
// This code is contributed by AnkitRai01

// C# implementation of the above approach
using System;
 
class GFG
{
     
    // Function to return the lowest power
    // of 2 close to given positive number
    static int powOfPositive(int n)
    {
        // Floor function is used to determine
        // the value close to the number
        int pos = (int)Math.Floor((Math.Log(n)/Math.Log(2)));
        return (int)Math.Pow(2, pos);
    }
     
    // Function to return the lowest power
    // of 2 close to given negative number
    static int powOfNegative(int n)
    {
        // Ceil function is used for negative numbers
        // as -1 > -4. It would be opposite
        // to positive numbers where 1 < 4
        int pos = (int)Math.Ceiling((Math.Log(n)/Math.Log(2)));
        return (int)(-1 * Math.Pow(2, pos));
    }
     
    // Function to find the highest power of 2
    static void highestPowerOf2(int n)
    {
     
        // To check if the given number
        // is positive or negative
        if (n > 0)
        {
            Console.WriteLine(powOfPositive(n));
        }
        else
        {
            // If the number is negative,
            // then the ceil of the positive number
            // is calculated and
            // negative sign is added
            n = -n;
            Console.WriteLine(powOfNegative(n));
        }
    }
     
    // Driver code
    public static void Main()
    {
        int n = -24;
        highestPowerOf2(n);
    }
}
 
// This code is contributed by AnkitRai01

# Python3 implementation of the above approach
from math import floor,ceil,log2
 
# Function to return the lowest power
# of 2 close to given positive number
def powOfPositive(n) :
 
    # Floor function is used to determine
    # the value close to the number
    pos = floor(log2(n));
    return 2**pos;
 
# Function to return the lowest power
# of 2 close to given negative number
def powOfNegative(n) :
 
    # Ceil function is used for negative numbers
    # as -1 > -4. It would be opposite
    # to positive numbers where 1 < 4
    pos = ceil(log2(n));
     
    return (-1 * pow(2, pos));
 
# Function to find the highest power of 2
def highestPowerOf2(n) :
 
    # To check if the given number
    # is positive or negative
    if (n > 0) :
        print(powOfPositive(n));
 
    else :
         
        # If the number is negative,
        # then the ceil of the positive number
        # is calculated and
        # negative sign is added
        n = -n;
        print(powOfNegative(n));
 
# Driver code
if __name__ == "__main__" :
 
    n = -24;
    highestPowerOf2(n);
 
# This code is contributed by AnkitRai01

<script>
 
// Javascript implementation of the above approach
 
// Function to return the lowest power
// of 2 close to given positive number
function powOfPositive(n)
{
     
    // Floor function is used to determine
    // the value close to the number
    let pos = Math.floor(Math.log2(n));
    return Math.pow(2, pos);
}
 
// Function to return the lowest power
// of 2 close to given negative number
function powOfNegative(n)
{
     
    // Ceil function is used for negative numbers
    // as -1 > -4. It would be opposite
    // to positive numbers where 1 < 4
    let pos = Math.ceil(Math.log2(n));
    return (-1 * Math.pow(2, pos));
}
 
// Function to find the highest power of 2
function highestPowerOf2(n)
{
 
    // To check if the given number
    // is positive or negative
    if (n > 0)
    {
        document.write(powOfPositive(n));
    }
    else
    {
         
        // If the number is negative,
        // then the ceil of the positive number
        // is calculated and
        // negative sign is added
        n = -n;
        document.write(powOfNegative(n));
    }
}
 
// Driver code
let n = -24;
 
highestPowerOf2(n);
 
// This code is contributed by mohit kumar 29
 
</script>

-32