java - trigonometricas - métodos del paquete math

Encuentre si un número es una potencia de dos sin función matemática o función de registro

Question

Quiero saber si un número ingresado por el usuario es una potencia de dos o no.

Mi código no funciona.

public class power_of_two
{  
    public static void main(String args[])  
    {  

        Scanner in=new Scanner(System.in);
        System.out.println("Enter the number : ");
        int num = in.nextInt();

        int other = 1;  
        if(((~num) & 1) == 1)  
        {  
            System.out.println("The number is a power of two");  
        }  
        else  
        {
            System.out.println("The number is a  NOT A power of two");  
        }
    }  
} 

Déjame saber cómo puedo encontrar el poder de dos números.
Por ejemplo 8 es una potencia de 2.
22 no es una potencia de 2, etc.

Answer 1

La solución sencilla:

bool isPowerOfTwo(int n) {
    // All values < 1 cannot be (positive, at least) powers of two.
    if (n < 1) return false;

    // Keep shifting bits.
    while (n > 1) {
        // Since n > 1, the low bit set means at least two bits must
        // be set, making n no longer a power of two.
        if (n & 0x1) return false;
        // Throw away the bottom (zero) bit.
        n >>= 1;
    }
    // Only one bit was set, therefore, n is a power of two.
    return true;
}

Por supuesto, esto no es tan óptimo como algunas de las otras soluciones de trucos de bits (que son bastante inteligentes), pero es muy fácil ver cómo funciona y verificar que funcione en su cabeza.

Para la entrada 4 , obtenemos:

n = 4 (0x100)
run loop
n = 2 (0x10)
run loop
n = 1 (0x1)
return true

Para una entrada no válida, como 5 , obtenemos:

n = 5 (0x101)
return false (0x101 & 0x1 => 0x1, which is truthy)

Answer 2

Puede utilizar el bitwise AND (&) operator :

return (num & -num) == num

¿Por qué esto funciona?

Considere el número 8, ¿qué es en binario (suponiendo 32 bits)?

0000 0000 0000 0000 0000 0000 0000 1000

Ahora veamos como se representa -8? ¹

1111 1111 1111 1111 1111 1111 1111 1000

Finalmente ... calculemos 8 & -8 :

0000 0000 0000 0000 0000 0000 0000 1000   8
↓↓↓↓ ↓↓↓↓ ↓↓↓↓ ↓↓↓↓ ↓↓↓↓ ↓↓↓↓ ↓↓↓↓ ↓↓↓↓   &
1111 1111 1111 1111 1111 1111 1111 1000  -8
---------------------------------------
0000 0000 0000 0000 0000 0000 0000 1000   8    ¯/_(ツ)_/¯

Ahora tomemos otro ejemplo, digamos 7 , que no es potencia de dos.

0000 0000 0000 0000 0000 0000 0000 0111   7
↓↓↓↓ ↓↓↓↓ ↓↓↓↓ ↓↓↓↓ ↓↓↓↓ ↓↓↓↓ ↓↓↓↓ ↓↓↓↓   &                       
1111 1111 1111 1111 1111 1111 1111 1001  -7
---------------------------------------
0000 0000 0000 0000 0000 0000 0000 0001  != 7  ¯/_(ة_ة)_/¯

Como lo mencionó @arshajii, piense qué pasará si num es cero. Le dejaré la solución :)

¹ Una buena manera de recordar cómo calcular eso: comience desde el bit más a la derecha, por cada 0 que vea, no lo cambie, cuando vea 1, déjelo y continúe, pero a partir de ahora, invierta todos los bits. Traté de explicar esto más here .

Answer 3

Puedes probar si un entero positivo n es una potencia de 2 con algo como

(n & (n - 1)) == 0

Si n puede ser no positivo (es decir, negativo o cero), debe usar

(n > 0) && ((n & (n - 1)) == 0)

Si n es realmente una potencia de 2, entonces en binario se verá así:

10000000...

entonces n - 1 parece

01111111...

y cuando tengamos bitwise-AND ellos:

  10000000...
& 01111111...
  -----------
  00000000...

Ahora, si n no es una potencia de 2, entonces su representación binaria tendrá algunos otros 1 además del 1 inicial, lo que significa que tanto n como n - 1 tendrán el mismo 1 bit inicial (ya que restar 1 no puede desactiva este bit si hay otro 1 en la representación binaria en algún lugar). Por lo tanto, la operación & no puede producir 0 si n no es una potencia de 2, ya que los dos bits principales de n y n - 1 producirán 1 en sí mismo. Esto, por supuesto, asume que n es positivo.

Esto también se explica en "Algoritmo rápido para verificar si un número positivo es una potencia de dos" en Wikipedia.

Verificación rápida de la cordura:

for (int i = 1; i <= 100; i++) {
    if ((i & (i - 1)) == 0)
        System.out.println(i);
}

1 2 4 8 16 32 64

Answer 4

Una solución muy simple.

int n = 8; // any integer and you can take it from user also
for(;n>0;n++){
    if(n%2 != 0) {
        System.out.println("not a power of two")
        return;
    } // if ends here
    n = n/2;
}// for ends here
System.out.println("power of two")

Answer 5

double input = 22;

while(((input != 2) && input % 2 == 0) || input == 1) {
 input = input /2;
}

return input == 2;

Continúa dividiéndolo por 2 hasta que alcances 1 o un número impar. Si llega a 1 es una potencia de 2, de lo contrario no lo es.

Answer 6

   public boolean isPowerOfTwo(int n){

            boolean isPower=false;
            int temp=n;

            while(temp>=2){
                if(temp%2==0){
                    isPower=true;

                }else{
                    isPower=false;
                    break;
                }
                temp=temp/2;
            }

            if(isPower){
                System.out.println("power of 2");
            }else{
                System.out.println("not power of 2");
            }

            return isPower;
        }