วิธีการยกกำลังใน Java

ธารคณิต

วิธีที่ง่ายที่สุดในการแก้ปัญหานี้คือการใช้วิชาคณิตศาสตร์ นี่คือวิธีแก้ปัญหาที่คุณจะใช้ในกรณีส่วนใหญ่

ชั้นเรียนคณิตศาสตร์ประกอบด้วยวิธีการที่เกี่ยวข้องกับตรีโกณมิติ เรขาคณิต และแง่มุมอื่นๆ ของคณิตศาสตร์ ในนั้นเมธอดจะถูกนำไปใช้เป็นแบบคงที่ ดังนั้นคุณสามารถเรียกเมธอดเหล่านั้นผ่านชื่อของคลาส Math ได้ทันทีโดยไม่ต้องสร้างคลาสอ็อบเจ็กต์

การยกกำลังมีลักษณะอย่างไร:

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

เราต้องใช้ type cast (int) เนื่องจากเมธอดของคลาส Math นี้ส่งคืนค่าประเภท double (อาร์กิวเมนต์ก็เป็นสองเท่าเช่นกัน แต่มีการใช้ประเภทโดยนัยที่นั่น)

และตอนนี้ - โบนัส: ตัวเลือกเพิ่มเติม

ค่าของกำลังสองของตัวเลข

เรามาเริ่มกันด้วยสิ่งที่ง่ายที่สุด

นี่คือวิธีการเขียนวิธีการยกกำลังสอง:

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

โทรเข้าหลัก:

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

นั่นคือทั้งหมด - ไม่มีอะไรซับซ้อนหรือไม่จำเป็น

ตัวเลขยกกำลัง

แต่จำนวนกำลังสองไม่ใช่ทั้งหมดที่เราต้องการ บ่อยครั้งในงานของเรา เราจะต้องมีตัวเลขในระดับหนึ่ง ดังนั้นสิ่งต่อไปนี้จะเป็นเวอร์ชันที่ซับซ้อนกว่าเล็กน้อย แต่ด้วยค่า 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;
}

อัลกอริธึมนั้นง่ายมาก: เราตั้งค่าผลลัพธ์ของจุดเริ่มต้นแล้วคูณด้วยค่าของเราหลาย ๆ ครั้งในขณะที่ลูปที่มี powValue ทำงาน (จำนวน powValue)

การเรียกซ้ำ

วิธีต่อไปจะแปลกใหม่กว่านี้เล็กน้อย แต่ก็เจ๋งไม่น้อย

การเรียกซ้ำเป็นคุณลักษณะที่ช่วยให้วิธีการเรียกตัวเองได้ ใน Java มีกลไกดังกล่าวอยู่ และวิธีการดังกล่าวจึงเรียกว่าแบบเรียกซ้ำ

ปัญหาอัลกอริทึมจำนวนมาก (หรือทั้งหมด) สามารถแก้ไขได้แบบวนซ้ำ อันนี้ก็ไม่มีข้อยกเว้นเช่นกัน ดังนั้นเรามาดูกันว่าคุณสามารถเพิ่มจำนวนให้เป็นกำลังที่แน่นอนด้วยวิธีวนซ้ำได้อย่างไร:

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

อย่างที่เราเห็น เรามีสองกรณี:

1. เงื่อนไขสำหรับการออกจากการเรียกซ้ำ หรืออีกนัยหนึ่ง เมื่อค่าดีกรีของเราถึงหนึ่ง เราจะเริ่มถูกโยนกลับ
2. กลไกในการคูณค่าด้วยผลลัพธ์ของการเรียกวิธีเดียวกัน แต่ด้วย powValue - 1

ตอนนี้ได้เวลาดูวิธีการแบบ Lazy มากขึ้น ซึ่งก็คือวิธี "นอกกรอบ"

จำนวนเต็มใหญ่

วัตถุประสงค์หลักของคลาส BigInteger คือการจัดเก็บจำนวนเต็มที่มีขนาดตามใจชอบ แต่ในขณะเดียวกันก็มีวิธีการทางคณิตศาสตร์ที่หลากหลายที่ช่วยให้คุณสามารถทำงานกับตัวเลขขนาดใหญ่ (หรือไม่ใหญ่มาก) เหล่านี้ได้

คุณสามารถอ่านเพิ่มเติมเกี่ยวกับ BigInteger ได้ในบทความนี้

แล้วการยกกำลังจะเป็นอย่างไรเมื่อใช้ BigInteger ใน Java?

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

ค่อนข้างง่ายและไม่มีปัญหาใช่ไหม?