Paano Mag-Exponentiate sa Java

Math pow

Ang pinakamadaling paraan upang malutas ang problemang ito ay ang paggamit ng klase sa Math. Ito ang solusyon na gagamitin mo sa karamihan ng mga kaso.

Ang klase ng Math ay naglalaman ng mga pamamaraan na nauugnay sa trigonometrya, geometry, at iba pang aspeto ng matematika. Sa loob nito, ang mga pamamaraan ay ipinatupad bilang static, kaya maaari mong agad na tawagan ang mga ito sa pamamagitan ng pangalan ng klase ng Math nang hindi gumagawa ng object ng klase.

Ano ang hitsura ng exponentiation:

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

Kinailangan naming gumamit ng isang uri ng cast (int), dahil ang pamamaraang ito ng klase ng Math ay nagbabalik ng isang halaga ng uri ng doble (doble rin ang mga argumento, ngunit isang implicit na uri ng cast ang ginagamit doon).

At ngayon - isang bonus: karagdagang mga pagpipilian.

Ang halaga ng parisukat ng isang numero

Magsimula tayo, marahil, sa pinakasimpleng bagay.

Ito ay kung paano isinulat ang paraan para sa pag-squaring:

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

Tumawag sa pangunahing:

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

Iyon lang - walang kumplikado o hindi kailangan.

Numero sa kapangyarihan

Ngunit ang squared number ay hindi lang ang kailangan natin. Kadalasan sa aming trabaho kakailanganin namin ang isang numero sa isang tiyak na antas, kaya ang sumusunod ay isang bahagyang mas kumplikadong bersyon, ngunit may isang pasadyang halaga ng java pow:

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;
}

Ang algorithm ay napaka-simple: itinakda namin ang resulta ng panimulang punto, at pagkatapos ay i-multiply ito sa aming halaga nang maraming beses habang tumatakbo ang loop na may powValue (bilang ng beses ng powValue)

Recursion

Ang susunod na paraan ay magiging mas kakaiba, ngunit hindi gaanong cool.

Ang recursion ay isang feature na nagbibigay-daan sa isang paraan na tawagan ang sarili nito. Sa Java, ang gayong mekanismo ay naroroon, at ang mga naturang pamamaraan ay naaayon na tinatawag na recursive.

Marami, kung hindi man lahat, ang mga problema sa algorithm ay maaaring malutas nang recursively. Ang isang ito ay hindi rin magiging eksepsiyon, kaya tingnan natin kung paano mo maitataas ang isang numero sa isang tiyak na kapangyarihan sa isang recursive na paraan:

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

Tulad ng nakikita natin, mayroon tayong dalawang kaso:

1. Ang kundisyon para sa pag-alis sa recursion, o sa madaling salita, kapag ang halaga ng ating antas ay umabot sa isa, magsisimula tayong itapon pabalik.
2. Ang mekanismo mismo para sa pagpaparami ng halaga sa pamamagitan ng resulta ng pagtawag sa parehong paraan, ngunit may powValue - 1.

Buweno, ngayon ay oras na upang tingnan ang mas tamad na mga pamamaraan, ibig sabihin, ang mga "out of the box" na mga pamamaraan.

BigInteger

Ang pangunahing layunin ng klase ng BigInteger ay mag-imbak ng mga integer na may di-makatwirang laki, ngunit sa parehong oras mayroon itong iba't ibang mga pamamaraan ng aritmetika na nagbibigay-daan sa iyo upang gumana sa mga malalaking (o hindi masyadong malaki) na mga numero.

Maaari kang magbasa nang higit pa tungkol sa BigInteger sa artikulong ito .

Kaya ano ang magiging hitsura ng exponentiation gamit ang BigInteger sa Java?

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

Medyo simple at walang anumang problema, hindi ba?