java - saca - Cálculo de potencias de enteros

potencia iterativa java

Question

¿Hay alguna otra forma en Java para calcular la potencia de un entero?

Utilizo Math.pow(a, b) ahora, pero devuelve un doble, y eso es generalmente mucho trabajo, y parece menos limpio cuando solo quieres usar enteros (una potencia también dará como resultado un entero) .

¿Hay algo tan simple como a**b como en Python?

Answer 1

A diferencia de Python (donde los poderes se pueden calcular con ** **), JAVA no tiene esa forma de acceso directo para lograr el resultado de la potencia de dos números. Java tiene una función llamada pow en la clase Math, que devuelve un valor doble

double pow(double base, double exponent)

Pero también puedes calcular las potencias de un entero usando la misma función. En el siguiente programa hice lo mismo y finalmente estoy convirtiendo el resultado en un entero (encasillado). Sigue el ejemplo:

import java.util.*;
import java.lang.*; // CONTAINS THE Math library
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n= sc.nextInt(); // Accept integer n
        int m = sc.nextInt(); // Accept integer m
        int ans = (int) Math.pow(n,m); // Calculates n ^ m
        System.out.println(ans); // prints answers
    }
}

Alternativamente, The java.math.BigInteger.pow(int exponent) devuelve un BigInteger cuyo valor es (este ^ exponente). El exponente es un número entero en lugar de un BigInteger. Ejemplo:

import java.math.*;
public class BigIntegerDemo {
public static void main(String[] args) {
      BigInteger bi1, bi2; // create 2 BigInteger objects          
      int exponent = 2; // create and assign value to exponent
      // assign value to bi1
      bi1 = new BigInteger("6");
      // perform pow operation on bi1 using exponent
      bi2 = bi1.pow(exponent);
      String str = "Result is " + bi1 + "^" +exponent+ " = " +bi2;
      // print bi2 value
      System.out.println( str );
   }
}

Answer 2

Bueno, puedes simplemente usar Math.pow(a,b) como lo has usado anteriormente y simplemente convertir su valor usando (int) antes. A continuación podría usarse como ejemplo.

int x = (int) Math.pow(a,b);

donde a y b podrían ser valores double o int según lo que desee. Esto simplemente convertirá su salida en un valor entero según lo requiera.

Answer 3

Cuando es poder de 2. Tenga en cuenta que puede usar un ejemplo simple y rápido de 1 << exponente.

2 ² = (int) Math.pow(2, 2) == 1 << 2
2 ¹⁰ = (int) Math.pow(2, 10) == 1 << 10

Para exponentes más grandes (más de 31) use long

2 ³² = (long) Math.pow(2, 32) == 1L << 32

por cierto. en Kotlin tienes shl lugar de << entonces

1L << 32 == 1L shl 32

Answer 4

El mejor algoritmo se basa en la definición de potencia recursiva de a ^ b.

long pow (long a, int b)
{
    if ( b == 0)        return 1;
    if ( b == 1)        return a;
    if (isEven( b ))    return     pow ( a * a, b/2); //even a=(a^2)^b/2
    else                return a * pow ( a * a, b/2); //odd  a=a*(a^2)^b/2

}

El tiempo de ejecución de la operación es O (logb). Referencia: Más información

Answer 5

Google Guava tiene utilidades matemáticas para enteros. IntMath

Answer 6

Las bibliotecas matemáticas de Guava ofrecen dos métodos que son útiles al calcular las potencias enteras exactas:

pow(int b, int k) calcula b a k la potencia y se ajusta al desbordamiento

checkedPow(int b, int k) es idéntico, excepto que arroja ArithmeticException en overflow

Personalmente checkedPow() satisface la mayoría de mis necesidades para la exponenciación de enteros y es más limpio y seguro que usar las versiones dobles y el redondeo, etc. En casi todos los lugares que quiero una función de potencia, el desbordamiento es un error (o imposible, pero quiero ser informado si lo imposible llega a ser posible).

Si desea obtener un resultado long , puede usar los métodos LongMath correspondientes y pasar los argumentos int .

Answer 7

Los enteros son solo 32 bits. Esto significa que su valor máximo es 2^31 -1 . Como puede ver, para números muy pequeños, obtiene rápidamente un resultado que ya no puede ser representado por un número entero. Es por eso que Math.pow usa el doble.

Si quieres una precisión entera arbitraria, usa BigInteger.pow . Pero, por supuesto, es menos eficiente.

Answer 8

Me las arreglé para modificar (límites, incluso control, verificación negativa de nums) Qx__ respuesta. Úselo bajo su propio riesgo. 0 ^ -1, 0 ^ -2 etc. ... devuelve 0.

private static int pow(int x, int n) {
        if (n == 0)
            return 1;
        if (n == 1)
            return x;
        if (n < 0) { // always 1^xx = 1 && 2^-1 (=0.5 --> ~ 1 )
            if (x == 1 || (x == 2 && n == -1))
                return 1;
            else
                return 0;
        }
        if ((n & 1) == 0) { //is even 
            long num = pow(x * x, n / 2);
            if (num > Integer.MAX_VALUE) //check bounds
                return Integer.MAX_VALUE; 
            return (int) num;
        } else {
            long num = x * pow(x * x, n / 2);
            if (num > Integer.MAX_VALUE) //check bounds
                return Integer.MAX_VALUE;
            return (int) num;
        }
    }

Answer 9

No, no hay algo tan corto como a**b

Aquí hay un bucle simple, si quieres evitar dobles:

long result = 1;
for (int i = 1; i <= b; i++) {
   result *= a;
}

Si desea utilizar pow y convertir el resultado en entero, envíe el resultado de la siguiente manera:

int result = (int)Math.pow(a, b);

Answer 10

Una implementación simple (sin comprobaciones de desbordamiento o de validez de argumentos) para el algoritmo de cuadratura repetida para calcular la potencia:

/** Compute a**p, assume result fits in a 32-bit signed integer */ 
int pow(int a, int p)
{
    int res = 1;
    int i1 = 31 - Integer.numberOfLeadingZeros(p); // highest bit index
    for (int i = i1; i >= 0; --i) {
        res *= res;
        if ((p & (1<<i)) > 0)
            res *= a;
    }
    return res;
}

La complejidad del tiempo es logarítmica al exponente p (es decir, es lineal al número de bits requerido para representar p).

Answer 11

Use la lógica a continuación para calcular la n potencia de a.

Normalmente si queremos calcular n potencia de a. Multiplicaremos ''a'' por n número de veces. La complejidad del tiempo de este enfoque será O (n) Dividir la potencia n por 2, calcular Exponentattion = multiplicar ''a'' hasta n / 2 solamente. Duplicar el valor Ahora la Complejidad del Tiempo se reduce a O (n / 2).

public  int calculatePower1(int a, int b) {
    if (b == 0) {
        return 1;
    }

    int val = (b % 2 == 0) ? (b / 2) : (b - 1) / 2;

    int temp = 1;
    for (int i = 1; i <= val; i++) {
        temp *= a;
    }

    if (b % 2 == 0) {
        return temp * temp;
    } else {
        return a * temp * temp;
    }
}

Answer 12

import java.util.*;
public class Power {

    public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        int num = 0;
        int pow = 0;
        int power = 0;

        System.out.print("Enter number: ");
        num = sc.nextInt();

        System.out.print("Enter power: ");
        pow = sc.nextInt();

        System.out.print(power(num,pow));
    }
    public static int power(int a, int b)
    {
            int power = 1;
            for(int c=0;c<b;c++)
            power*=a;
            return power;
        }

}