Calcul des puissances de nombres entiers
Existe-t-il un autre moyen en Java de calculer la puissance d’un entier?
J'utilise maintenant Math.pow(a, b), mais cela retourne un double, ce qui représente généralement beaucoup de travail et semble moins net lorsque vous voulez simplement utiliser des entiers (une puissance aboutira également toujours à un entier).
Y at-il quelque chose d'aussi simple que a**b comme en Python?
Les entiers ne sont que 32 bits. Cela signifie que sa valeur maximale est 2^31 -1. Comme vous le voyez, pour de très petits nombres, vous obtenez rapidement un résultat qui ne peut plus être représenté par un entier. C'est pourquoi Math.pow utilise double.
Si vous voulez une précision entière arbitraire, utilisez BigInteger.pow . Mais c'est bien sûr moins efficace.
Mieux l’algorithme est basé sur la définition de puissance récursive 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
}
Le temps d'exécution de l'opération est O (logb) . Référence: Plus d'informations
Non, il n'y a pas quelque chose d'aussi court que a**b
Voici une boucle simple, si vous voulez éviter les doublons:
long result = 1;
for (int i = 1; i <= b; i++) {
result *= a;
}
Si vous souhaitez utiliser pow et convertir le résultat en entier, convertissez le résultat comme suit:
int result = (int)Math.pow(a, b);
Google Guava propose des utilitaires mathématiques pour les nombres entiers . IntMath
Quand c'est puissance de 2. Gardez à l'esprit que vous pouvez utiliser une expression simple et rapide avec décalage 1 << exponent
exemple:
22 = 1 << 2 = (int) Math.pow(2, 2)
2dix = 1 << 10 = (int) Math.pow(2, 10)
Pour les exposants plus grands (plus de 31), utilisez long à la place
232 = 1L << 32 = (long) Math.pow(2, 32)
btw. dans Kotlin, vous avez shl au lieu de << afin
(Java) 1L << 32 = 1L shl 32 (kotlin)
Eh bien, vous pouvez simplement utiliser Math.pow(a,b) comme vous avez utilisé précédemment et simplement convertir sa valeur en utilisant (int) avant. Ci-dessous pourrait être utilisé comme exemple.
int x = (int) Math.pow(a,b);
où a et b pourraient être les valeurs double ou int que vous voulez . Cela convertira simplement sa sortie en valeur entière, comme vous le souhaitez.
Les bibliothèques de mathématiques de Guava proposent deux méthodes utiles pour calculer des puissances entières exactes:
pow(int b, int k) calcule b à la kième de la puissance et termine le débordement
checkedPow(int b, int k) est identique sauf qu'il jette ArithmeticException en débordement
Personnellement, checkedPow() répond à la plupart de mes besoins en termes d’exposants entiers et est plus propre et plus sûr que d’utiliser les versions doubles et les arrondis, etc. Dans presque tous les endroits où je souhaite une fonction d’alimentation, le dépassement de capacité est une erreur si l'impossible devient jamais possible).
Si vous voulez obtenir un résultat long, vous pouvez simplement utiliser les méthodes LongMath correspondantes et passer les arguments int.
J'ai réussi à modifier (limites, même vérifier, contrôle de nums négatif) Qx__ réponse. À utiliser à vos risques et périls. 0 ^ -1, 0 ^ -2 etc .. renvoie 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;
}
}
Une implémentation simple (sans contrôle de dépassement de capacité ni de validité des arguments) pour l'algorithme de quadrature répétée utilisée pour calculer la puissance
/** 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 complexité temporelle est logarithmique à exposant p (c’est-à-dire linéaire au nombre de bits requis pour représenter p).
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;
}
}
base est le nombre que vous voulez mettre sous tension, n est le pouvoir, nous retournons 1 si n vaut 0 et nous retournons la base si n est 1, si les conditions ne sont pas remplies, nous utilisons la formule base * (powerN (base, n-1)) par exemple: 2 surélevé à à l'aide de cette formule est: 2 (base) * 2 (powerN (base, n-1)).
public int power(int base, int n){
return n == 0 ? 1 : (n == 1 ? base : base*(power(base,n-1)));
}
Contrairement à Python (où les puissances peuvent être calculées par un ** b), Java ne dispose pas de cette méthode de raccourci pour obtenir le résultat de la puissance de deux nombres . Java a une fonction nommée pow dans la classe Math, qui renvoie une valeur Double.
double pow(double base, double exponent)
Mais vous pouvez également calculer des puissances de nombre entier en utilisant la même fonction. Dans le programme suivant, j'ai fait la même chose et enfin, je convertis le résultat en entier (conversion de type). Suivre l'exemple:
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
}
}
Sinon, Java.math.BigInteger.pow(int exponent) renvoie un BigInteger dont la valeur est (this ^ exposant). L'exposant est un entier plutôt qu'un BigInteger. Exemple:
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 );
}
}
Utilisez la logique ci-dessous pour calculer la puissance n de a.
Normalement, si nous voulons calculer n puissance de a. Nous allons multiplier 'a' par n nombre de fois. La complexité temporelle de cette approche sera de O (n) Divisez la puissance n par 2, calculez Exponention = multipliez 'a' jusqu'à n/2 seulement. Double la valeur. Maintenant, la complexité temporelle est réduite à 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;
}
}