Come esponenziare in Java

Prova di matematica

Il modo più semplice per risolvere questo problema è utilizzare la classe Math. Questa è la soluzione che utilizzerai nella maggior parte dei casi.

La classe Math contiene metodi relativi alla trigonometria, alla geometria e ad altri aspetti della matematica. In esso, i metodi sono implementati come statici, quindi puoi chiamarli immediatamente tramite il nome della classe Math senza creare un oggetto di classe.

Che aspetto ha l'elevamento a potenza:

public static int pow(int value, int powValue) {
   return (int) Math.pow(value, powValue);
}

Abbiamo dovuto utilizzare un cast di tipo (int), poiché questo metodo della classe Math restituisce un valore di tipo double (anche gli argomenti sono double, ma lì viene utilizzato un cast di tipo implicito).

E ora - un bonus: opzioni aggiuntive.

Il valore del quadrato di un numero

Cominciamo, forse, con la cosa più semplice.

Ecco come viene scritto il metodo per la quadratura:

public static int pow(int value){
   return value*value;
}

Chiama in principale:

public static void main(String[] args) {
   System.out.println(Solution.pow(7));
}

Questo è tutto: niente di complicato o inutile.

Numero elevato alla potenza

Ma il numero quadrato non è tutto ciò di cui abbiamo bisogno. Molto spesso nel nostro lavoro avremo bisogno di un numero in una certa misura, quindi quella che segue è una versione leggermente più complicata, ma con un valore Java Pow personalizzato:

public static void main(String[] args) {
   System.out.println(Solution.pow(7, 4));
}

public static int pow(int value, int powValue) {
   int result = 1;
   for (int i = 1; i <= powValue; i++) {
       result = result * value;
   }
   return result;
}

L'algoritmo è molto semplice: impostiamo il risultato del punto iniziale e poi lo moltiplichiamo per il nostro valore tante volte quante viene eseguito il ciclo con powValue (numero di volte powValue)

Ricorsione

Il prossimo metodo sarà un po’ più esotico, ma non per questo meno interessante.

La ricorsione è una funzionalità che consente a un metodo di chiamare se stesso. In Java è presente un tale meccanismo e tali metodi sono di conseguenza chiamati ricorsivi.

Molti, se non tutti, i problemi algoritmici possono essere risolti ricorsivamente. Anche questo non farà eccezione, quindi diamo un'occhiata a come puoi elevare un numero a una certa potenza in modo ricorsivo:

public static int pow(int value, int powValue) {
   if (powValue == 1) {
       return value;
   } else {
       return value * pow(value, powValue - 1);
   }
}

Come possiamo vedere abbiamo due casi:

1. La condizione per uscire dalla ricorsione, o in altre parole, quando il nostro valore di laurea raggiunge uno, inizieremo a essere respinti.
2. Il meccanismo stesso per moltiplicare il valore per il risultato della chiamata allo stesso metodo, ma con powValue - 1.

Bene, ora è il momento di considerare i metodi più pigri, vale a dire i metodi “fuori dagli schemi”.

BigInteger

Lo scopo principale della classe BigInteger è memorizzare numeri interi di dimensione arbitraria, ma allo stesso tempo ha vari metodi aritmetici che ti consentono di lavorare con questi numeri enormi (o non così grandi).

Puoi leggere ulteriori informazioni su BigInteger in questo articolo .

Quindi come sarebbe l'elevamento a potenza utilizzando BigInteger in Java?

public static int pow(int value, int powValue) {
   BigInteger a = new BigInteger(String.valueOf(value));
  return a.pow(powValue).intValue();
}

Abbastanza semplice e senza problemi, non è vero?