web-dev-qa-db-fra.com

comment obtenir des exposants sans utiliser math.pow pour java

C'est mon programme

// ************************************************************
    // PowersOf2.Java
    //
    // Print out as many powers of 2 as the user requests
    //
    // ************************************************************

    import Java.util.Scanner;

    public class PowersOf2 {

    public static void main(String[] args)

    {
        int numPowersOf2; //How many powers of 2 to compute
        int nextPowerOf2 = 1; //Current power of 2
        int exponent= 1;
        double x;

         //Exponent for current power of 2 -- this
        //also serves as a counter for the loop Scanner

        Scanner scan = new Scanner(System.in);
        System.out.println("How many powers of 2 would you like printed?");
        numPowersOf2 = scan.nextInt();
        System.out.println ("There will be " + numPowersOf2 + " powers of 2 printed");
        //initialize exponent -- the first thing printed is 2 to the what?

    while( exponent <= numPowersOf2)
        {
        double x1 = Math.pow(2, exponent);
        System.out.println("2^" + exponent + " = " + x1);
                exponent++;
        }   
//print out current power of 2
//find next power of 2 -- how do you get this from the last one?
//increment exponent

    }
}

Le fait est que je ne suis pas autorisé à utiliser la méthode math.pow, je dois trouver un autre moyen d'obtenir la bonne réponse dans la boucle while. 

javamathpowexponent
4
user3552056

Les puissances de 2 peuvent être simplement calculées par Opérateurs de décalage de bits

int exponent = ...
int powerOf2 = 1 << exponent;

Même pour la forme plus générale, vous devriez not calculer un exposant en "multipliant n fois". Au lieu de cela, vous pourriez faire Exponentiation par quadrature

7
Marco13

Vous pouvez implémenter votre propre fonction power.

La complexité de la fonction power dépend de vos exigences et de vos contraintes. Par exemple, vous pouvez contraindre les exposants à n'être que des entiers positifs.

Voici un exemple de fonction power:

public static double power(double base, int exponent) {
    double ans = 1;
    if (exponent != 0) {
        int absExponent = exponent > 0 ? exponent : (-1) * exponent;
        for (int i = 1; i <= absExponent; i++) {
            ans *= base;
        }

        if (exponent < 0) {
            // For negative exponent, must invert
            ans = 1.0 / ans;
        }
    } else {
        // exponent is 0
        ans = 1;
    }

    return ans;
}
1
wns349

voici comment je me suis débrouillé sans utiliser "myPow (x, n)", mais en utilisant "while". (Cela ne fait que 2 semaines que j'apprends Java, alors excusez-moi, si le code est un peu bosselé :) 

    String base ="";
    String exp ="";
    BufferedReader value = new BufferedReader (new InputStreamReader(System.in));
    try {System.out.print("enter the base number: ");
        base = value.readLine();
        System.out.print("enter the exponent: ");
        exp = value.readLine(); }
    catch(IOException e){System.out.print("error");}

    int x = Integer.valueOf(base);
    int n = Integer.valueOf(exp);
    int y=x;
    int m=1;       
    while(m<n+1) {
        System.out.println(x+"^"+m+"= "+y);
        y=y*x;
        m++;    
    }
0
AVos

Je sais que cette réponse est très tardive, mais il existe une solution très simple que vous pouvez utiliser si vous êtes autorisé à avoir des variables qui stockent la base et l’exposant.

public class trythis {
    public static void main(String[] args) {
        int b = 2;
        int p = 5;
        int r = 1;
        for (int i = 1; i <= p; i++) {
            r *= b;
        }
        System.out.println(r);
    }
}

Cela fonctionnera avec des bases positives et négatives, mais pas avec des pouvoirs négatifs.

0
Artemis Hunter
// Set the variables

int numPowersOf2;        //How many powers of 2 to compute
int nextPowerOf2 = 1;    //Current power of  2
int exponent = 0;  


/* User input here */

// Loop and print results

do
   {

    System.out.println ("2^" + exponent + " = " + nextPowerOf2);

    nextPowerOf2 = nextPowerOf2*2;

    exponent ++;
  } 
while (exponent < numPowersOf2);
0
noob.coder

Il n'est pas clair si votre commentaire sur l'utilisation d'une boucle est un désir ou une exigence. Si vous le souhaitez, vous pouvez utiliser une identité mathématique qui ne repose pas sur Math.Pow

En Java, cela ressemblerait à

public static double myPow(double x, double y){
  return Math.exp(y*Math.log(x));
}

Si vous avez vraiment besoin d'une boucle, vous pouvez utiliser quelque chose comme ce qui suit

public static double myPow(double b, int e) {
  if (e < 0) {
    b = 1 / b;
    e = -e;
  }

  double pow = 1.0;
  double intermediate = b;
  boolean fin = false;

  while (e != 0) {
    if (e % 2 == 0) {
      intermediate *= intermediate;
      fin = true;
    } else {
      pow *= intermediate;
      intermediate = b;
      fin = false;
    }
    e >>= 1;
  }

  return pow * (fin ? intermediate : 1.0);
}
0
andand

Simplement:

double x1=1;

for(int i=1;i<=numPowersOf2;i++){
   x1 =* 2
}

S'il n'y a pas de contraintes de performance.

0
tutak

Voici un post qui permet des calculs de puissance négatifs/positifs.

https://stackoverflow.com/a/23003962/3538289

Fonction permettant de gérer les +/- exposants avec la complexité O(log(n)).

double power(double x, int n){
 if(n==0)
  return 1;

  if(n<0){
      x = 1.0/x;
      n = -n;
  }
 double ret = power(x,n/2);
 ret = ret * ret;
 if(n%2!=0)
   ret = ret * x;
 return ret;
}
0
cevaris

Pour implémenter la fonction pow sans utiliser Math.pow () intégré, nous pouvons utiliser la méthode récursive ci-dessous pour l'implémenter. Pour optimiser le temps d'exécution, nous pouvons stocker le résultat de l'alimentation (a, b/2) et le réutiliser en fonction du nombre de fois qu'il est pair ou impair.

static float power(float a, int b)
{
    float temp;
    if( b == 0)
        return 1;
    temp = power(a, b/2); 

    // if even times
    if (b%2 == 0)
        return temp*temp;
    else  // if odd times
    {
        if(b > 0)
            return a * temp * temp;
        else  // if negetive i.e. 3 ^ (-2)
            return (temp * temp) / a;
    }
}
0
mpatel