Comment écrire une fonction qui permet de calculer la puissance en Java. Pas de boucles

J'ai essayé d'écrire une fonction simple en Java qui permet de calculer un nombre à la puissance n, sans l'aide de boucles.
J'ai ensuite trouvé le Mathématiques.pow(a, b) classe... ou la méthode ne peut pas toujours distinguer les deux n'en suis pas si bon avec la théorie. J'ai donc écrit ce..

public static void main(String[] args) {

    int a = 2;

    int b = 31;

    System.out.println(Math.pow(a, b));

    }

Puis j'ai voulu faire mon propre Mathématiques.pow sans l'aide de boucles, je voulais qu'il ressemble de plus simple que de boucles, comme l'utilisation d'un certain type de Répéter j'ai fait beaucoup de recherche jusqu'à ce que je tombe sur le communes-lang3 paquet j'ai essayé d'utiliser StringUtils.répétez
Jusqu'à présent, je pense que c'est la Syntaxe:-

public static String repeat(String str, int repeat)
    StringUtils.repeat("ab", 2);

La problème j'ai été confrontée à la dernières 24h ou plus, c'est que StringUtils.répéter(String str, int 2); répète les chaînes non résu ou de chiffres, ou des calculs.
Est-ce que je peux faire pour surmonter ce ou n'importe quelle autre meilleure approche pour la création d'une fonction qui calcule pouvoirs?
sans l'aide de boucles ou les Mathématiques.pow

Cela pourrait être drôle, mais il m'a fallu du temps pour comprendre que StringUtils.répétez seuls les répétitions des chaînes c'est la façon dont j'ai essayé de le surmonter. incase il aide

 public static int repeat(int cal, int repeat){
     cal = 2+2;
     int result = StringUtils.repeat(cal,2);
     return result;
}

puis-je pas utiliser la récursivité peut-être quelque chose comme cela

public static RepeatThis(String a)
{
     System.out.println(a);
     RepeatThis(a);
}

juste essayer de comprendre le code java dans le dept merci à tous pour vos commentaires même si il y avait des erreurs de syntaxe tant que la logique était entendu que c'était bien pour moi 🙂

Le fait qu'elle est appelée StringUtils devrait vous donner un indice que c'est pour travailler avec Strings et non pas les numéros de...
Si vous essayez de re-mettre en œuvre des Mathématiques.pow() à des fins d'apprentissage puis les beaux mais sinon, il suffit de coller à ce défaut de mise en œuvre. Vous ne serez pas en mesure d'écrire un meilleur vous-même. À l'aide de la non-mise en œuvre standard seulement ajouter de la complexité à votre code et rend plus difficile pour d'autres personnes à comprendre.
oui, vous avez raison.
oui, c'est bien évidemment pour objectif d'apprentissage. Je ne pense pas qu'il y est un point de re-mettre en place quelque chose comme les Mathématiques.pow() atleast pas avec mon niveau de compétences. mais encore merci pour les conseils, c'est toujours bon de se rappeler de ces choses 🙂

OriginalL'auteur Mo Arctic | 2013-10-17

  1. 7

    Essayer avec la récursivité:

    int pow(int base, int power){
    if(power == 0) return 1;
    return base * pow(base, --power);
}
    je ne peux pas utiliser la récursivité peut-être quelque chose comme ce public static RepeatThis(Chaîne a) { System..println(a); RepeatThis(a); }
    Vous pouvez le faire aussi par la simulation de la pile. Vous devez également vous rappeler que chaque itération peut être converti à la récursivité, mais pas tous de la récursivité peut être converti à l'itération. Fonction récursive deviennent de plus en plus importante, avec une hausse de la programmation fonctionnelle, afin de lui donner un essai.
    si vous souhaitez effectuer une opération de paramétrer un certain nombre de fois, vous avez à boucle ou de manière récursive. Il n'y a pas d'autre moyen de le faire. Que pensez-vous StringUtils.repeat?
    merci beaucoup je suis déjà à la recherche dans la récursivité, mais c'est vraiment gênant quand vous ne pouvez pas obtenir un code fait de la façon dont vous imaginé que ce serait la première fois hahaha
    l'Araignée oui je pense que je reçois maintenant. si vous cochez la case à ma question, vous verrez que j'ai édité, j'ai juste ajouté quelque chose à la fin. Je suppose que essayais juste de la force de cette logique en java. Merci 🙂

    OriginalL'auteur user987339

  2. 11

    Une autre mise en œuvre avec O(Log(n)) complexité 

    public static long pow(long base, long exp){        
    if(exp ==0){
        return 1;
    }
    if(exp ==1){
        return base;
    }

    if(exp % 2 == 0){
        long half = pow(base, exp/2);
        return half * half;
    }else{
        long half = pow(base, (exp -1)/2);
        return base * half * half;
    }       
}
    C'est une très bonne solution

    OriginalL'auteur Vaibhav Fouzdar

  3. 3

    Fonction pour gérer +/- exposants avec O(log(n)) complexité.

    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;

    }

    OriginalL'auteur Gnanodharan Madahvan

  4. 1

    Je pense que dans la Production de la récursivité juste ne fournissent pas de haut de gamme performance. 

    double power(double num, int exponent)
{

double value=1;
int Originalexpn=exponent;
double OriginalNumber=num;

if(exponent==0)
    return value;

if(exponent<0)
{
    num=1/num;
    exponent=abs(exponent);
}

while(exponent>0)
{
    value*=num;
    --exponent;
}

cout << OriginalNumber << " Raised to  " << Originalexpn << " is " << value << endl;
return value;

    }

    OriginalL'auteur Angelo

  5. 0

    Utiliser ce code.

    public int mypow(int a, int e){
    if(e == 1) return a;
    return a * mypow(a,e-1);
}

    OriginalL'auteur RamonBoza

  6. 0

    Assurez-vous, créer votre propre fonction récursive:

    public static int repeat(int base, int exp) {
 if (exp == 1) {
  return base;
 }

 return base * repeat(base, exp - 1);
}

    Mathématiques.pow(a, b)

    Math est la classe, pow est la méthode, a et b sont les paramètres.

    Votre code est faux et ne fonctionne pas
    vous aviez raison, j'ai corrigé en conséquence.

    OriginalL'auteur Jeroen Vannevel

  7. 0

    Ce l'une des poignées exponentielle négative:

    public static double pow(double base, int e) {
    int inc;
    if(e <= 0) {
        base = 1.0 / base;
        inc = 1;
    }
    else {
        inc = -1;
    }
    return doPow(base, e, inc);
}

private static double doPow(double base, int e, int inc) {
    if(e == 0) {
        return 1;
    }
    return base * doPow(base, e + inc, inc);
}

    OriginalL'auteur myang

  8. 0

    Ici est un O(log(n)) le code qui calcule la puissance d'un nombre. La technique algorithmique utilisé est de diviser et conquérir. Il accepte aussi les puissances négatives i.e., x^(-y)

    import java.util.Scanner;

public class PowerOfANumber{
        public static void main(String args[]){
                float result=0, base;
                int power;
                PowerOfANumber calcPower = new PowerOfANumber();
                /* Get the user input for the base and power */
                Scanner input = new Scanner(System.in);
                System.out.println("Enter the base");   
                base=input.nextFloat();
                System.out.println("Enter the power");
                power=input.nextInt();
                result = calcPower.calculatePower(base,power);
                System.out.println(base + "^" + power + " is " +result);
        }   
        private float calculatePower(float x, int y){ 
                float temporary;
                /* Termination condition for recursion */    
                if(y==0)
                        return 1;
                temporary=calculatePower(x,y/2);
                /* Check if the power is even */
                if(y%2==0)
                        return (temporary * temporary);
                else{
                        if(y>0)
                                return (x * temporary * temporary);
                        else
                                return (temporary*temporary)/x;
                }    
        }
}

    OriginalL'auteur Var

  9. -1

    Une méthode récursive serait la méthode la plus simple pour cela :

    int power(int base, int exp) {
    if (exp != 1) {
        return (base * power(base, exp - 1));
    } else {
        return base;
    }
}

    où base est le nombre et la exp est le exponenet

    Ce n'est pas exactement de la compilation et il n'est pas formaté.
    Merci, j'ai oublié le reste.
    Vous n'avez pas besoin d'un else comme il y a un return. Il n'existe pas de crochets, qui est généralement une mauvaise pratique et le code est illisible.
    J'ai ajouté entre parenthèses. et else est obligatoire pour cette fonction btw sinon il l'habitude de compiler comme si l'état ne parvient pas, ce sera la fonction retournera whearas il doit retourner un int
    Nope, regardez les autres exemples. Vous avez besoin d'un if mais vous pouvez tout simplement return sans else. P. S. j'ai formaté votre code, je ne comprends vraiment pas ce qui est si difficile à ce sujet.

    OriginalL'auteur Aneesh