בחלק זה, נכתוב תוכניות Java כדי לקבוע את העוצמה של מספר. כדי לקבל את החזקה של מספר, הכפל את המספר במעריך שלו.

דוגמא:

נניח שהבסיס הוא 5 והמעריך הוא 4. כדי לקבל את החזקה של מספר, הכפל אותו בעצמו ארבע פעמים, כלומר (5 * 5 * 5 * 5 = 625).

כיצד לקבוע את כוחו של מספר?

• יש לקרוא או לאתחל את הבסיס והמעריך.
• קח כוח משתנה אחר והגדר אותו ל-1 כדי לשמור את התוצאה.
• הכפל את הבסיס בעוצמה ואחסן את התוצאה בעוצמה באמצעות לולאת for או while.
• חזור על שלב 3 עד שהמעריך יהיה שווה לאפס.
• הדפס את הפלט.

שיטות למציאת כוחו של מספר

קיימות מספר שיטות לקביעת החזקה של מספר:

Java string indexof

1. שימוש ב-Java for Loop
2. שימוש ב-Java בזמן לולאה
3. שימוש ברקורסיה
4. שימוש בשיטת Math.pow()
5. שימוש ב-Bit Manipulation

1. שימוש ב-Java for Loop

ניתן להשתמש בלולאת for כדי לחשב את העוצמה של מספר על ידי הכפלת הבסיס בעצמו שוב ושוב.

PowerOfNumber1.java

 public class PowerOfNumber1 { public static void main(String[] args) { int base = 2; int exponent = 3; int result = 1; for (int i = 0; i <exponent; i++) { result *="base;" } system.out.println(base + ' raised to the power of exponent is result); < pre> <p> <strong>Output:</strong> </p> <pre> 2 raised to the power of 3 is 8 </pre> <h3>2. Using Java while Loop</h3> <p>A while loop may similarly be used to achieve the same result by multiplying the base many times.</p> <p> <strong>PowerOfNumber2.java</strong> </p> <pre> public class PowerOfNumber2 { public static void main(String[] args) { int base = 2; int exponent = 3; int result = 1; int power=3; while (exponent &gt; 0) { result *= base; exponent--; } System.out.println(base + &apos; raised to the power of &apos; + power + &apos; is &apos; + result); } } </pre> <p> <strong>Output:</strong> </p> <pre> 2 raised to the power of 3 is 8 </pre> <h3>3. Using Recursion:</h3> <p>Recursion is the process of breaking down an issue into smaller sub-problems. Here&apos;s an example of how recursion may be used to compute a number&apos;s power.</p> <p> <strong>PowerOfNumber3.java</strong> </p> <pre> public class PowerOfNumber3 { public static void main(String[] args) { int base = 2; int exponent = 3; int result = power(base, exponent); System.out.println(base + &apos; raised to the power of &apos; + exponent + &apos; is &apos; + result); } public static int power(int base, int exponent) { if (exponent == 0) { return 1; } else { return base * power(base, exponent - 1); } } } </pre> <p> <strong>Output:</strong> </p> <pre> 2 raised to the power of 3 is 8 </pre> <h3>4. Using Math.pow() Method</h3> <p>The java.lang package&apos;s Math.pow() function computes the power of an integer directly.</p> <p> <strong>PowerOfNumber4.java</strong> </p> <pre> public class PowerOfNumber4 { public static void main(String[] args) { double base = 2.0; double exponent = 3.0; double result = Math.pow(base, exponent); System.out.println(base + &apos; raised to the power of &apos; + exponent + &apos; is &apos; + result); } } </pre> <p> <strong>Output:</strong> </p> <pre> 2.0 raised to the power of 3.0 is 8.0 </pre> <h3>Handling Negative Exponents:</h3> <p>When dealing with negative exponents, the idea of reciprocal powers might be useful. For instance, x^(-n) equals 1/x^n. Here&apos;s an example of dealing with negative exponents.</p> <p> <strong>PowerOfNumber5.java</strong> </p> <pre> public class PowerOfNumber5 { public static void main(String[] args) { double base = 2.0; int exponent = -3; double result = calculatePower(base, exponent); System.out.println(base + &apos; raised to the power of &apos; + exponent + &apos; is: &apos; + result); } static double calculatePower(double base, int exponent) { if (exponent &gt;= 0) { return calculatePositivePower(base, exponent); } else { return 1.0 / calculatePositivePower(base, -exponent); } } static double calculatePositivePower(double base, int exponent) { double result = 1.0; for (int i = 0; i <exponent; i++) { result *="base;" } return result; < pre> <p> <strong>Output:</strong> </p> <pre> 2.0 raised to the power of -3 is: 0.125 </pre> <h3>Optimizing for Integer Exponents:</h3> <p>When dealing with integer exponents, you may optimize the calculation by iterating only as many times as the exponent value. It decreases the number of unneeded multiplications.</p> <p> <strong>PowerOfNumber6.java</strong> </p> <pre> public class PowerOfNumber6 { public static void main(String[] args) { double base = 2.0; int exponent = 4; double result = calculatePower(base, exponent); System.out.println(base + &apos; raised to the power of &apos; + exponent + &apos; is: &apos; + result); } static double calculatePower(double base, int exponent) { double result = 1.0; for (int i = 0; i <exponent; i++) { result *="base;" } return result; < pre> <p> <strong>Output:</strong> </p> <pre> 2.0 raised to the power of 4 is: 16.0 </pre> <h3>5. Using Bit Manipulation to Calculate Binary Exponents:</h3> <p>Bit manipulation can be used to better improve integer exponents. To do fewer multiplications, an exponent&apos;s binary representation might be used.</p> <p> <strong>PowerOfNumber7.java</strong> </p> <pre> public class PowerOfNumber7 { public static void main(String[] args) { double base = 2.0; int exponent = 5; double result = calculatePower(base, exponent); System.out.println(base + &apos; raised to the power of &apos; + exponent + &apos; is: &apos; + result); } static double calculatePower(double base, int exponent) { double result = 1.0; while (exponent &gt; 0) { if ((exponent &amp; 1) == 1) { result *= base; } base *= base; exponent &gt;&gt;= 1; } return result; } } </pre> <p> <strong>Output:</strong> </p> <pre> 2.0 raised to the power of 5 is: 32.0 </pre> <hr></exponent;></pre></exponent;></pre></exponent;>

2. שימוש ב-Java while Loop

ניתן להשתמש בלולאת while כדי להשיג את אותה תוצאה על ידי הכפלת הבסיס פעמים רבות.

PowerOfNumber2.java

arraylist ב-java

 public class PowerOfNumber2 { public static void main(String[] args) { int base = 2; int exponent = 3; int result = 1; int power=3; while (exponent > 0) { result *= base; exponent--; } System.out.println(base + ' raised to the power of ' + power + ' is ' + result); } } 

תְפוּקָה:

 2 raised to the power of 3 is 8 

3. שימוש ברקורסיה:

רקורסיה היא תהליך של פירוק בעיה לתת-בעיות קטנות יותר. הנה דוגמה לאופן שבו ניתן להשתמש ברקורסיה כדי לחשב את העוצמה של מספר.

PowerOfNumber3.java

 public class PowerOfNumber3 { public static void main(String[] args) { int base = 2; int exponent = 3; int result = power(base, exponent); System.out.println(base + ' raised to the power of ' + exponent + ' is ' + result); } public static int power(int base, int exponent) { if (exponent == 0) { return 1; } else { return base * power(base, exponent - 1); } } } 

תְפוּקָה:

 2 raised to the power of 3 is 8 

4. שימוש בשיטת Math.pow()

הפונקציה Math.pow() של חבילת java.lang מחשבת את העוצמה של מספר שלם ישירות.

השווה מחרוזת java

PowerOfNumber4.java

 public class PowerOfNumber4 { public static void main(String[] args) { double base = 2.0; double exponent = 3.0; double result = Math.pow(base, exponent); System.out.println(base + ' raised to the power of ' + exponent + ' is ' + result); } } 

תְפוּקָה:

 2.0 raised to the power of 3.0 is 8.0 

טיפול במעריכים שליליים:

כאשר עוסקים במעריכים שליליים, הרעיון של כוחות הדדיים עשוי להיות שימושי. לדוגמה, x^(-n) שווה ל-1/x^n. הנה דוגמה להתמודדות עם מעריכים שליליים.

PowerOfNumber5.java

 public class PowerOfNumber5 { public static void main(String[] args) { double base = 2.0; int exponent = -3; double result = calculatePower(base, exponent); System.out.println(base + &apos; raised to the power of &apos; + exponent + &apos; is: &apos; + result); } static double calculatePower(double base, int exponent) { if (exponent &gt;= 0) { return calculatePositivePower(base, exponent); } else { return 1.0 / calculatePositivePower(base, -exponent); } } static double calculatePositivePower(double base, int exponent) { double result = 1.0; for (int i = 0; i <exponent; i++) { result *="base;" } return result; < pre> <p> <strong>Output:</strong> </p> <pre> 2.0 raised to the power of -3 is: 0.125 </pre> <h3>Optimizing for Integer Exponents:</h3> <p>When dealing with integer exponents, you may optimize the calculation by iterating only as many times as the exponent value. It decreases the number of unneeded multiplications.</p> <p> <strong>PowerOfNumber6.java</strong> </p> <pre> public class PowerOfNumber6 { public static void main(String[] args) { double base = 2.0; int exponent = 4; double result = calculatePower(base, exponent); System.out.println(base + &apos; raised to the power of &apos; + exponent + &apos; is: &apos; + result); } static double calculatePower(double base, int exponent) { double result = 1.0; for (int i = 0; i <exponent; i++) { result *="base;" } return result; < pre> <p> <strong>Output:</strong> </p> <pre> 2.0 raised to the power of 4 is: 16.0 </pre> <h3>5. Using Bit Manipulation to Calculate Binary Exponents:</h3> <p>Bit manipulation can be used to better improve integer exponents. To do fewer multiplications, an exponent&apos;s binary representation might be used.</p> <p> <strong>PowerOfNumber7.java</strong> </p> <pre> public class PowerOfNumber7 { public static void main(String[] args) { double base = 2.0; int exponent = 5; double result = calculatePower(base, exponent); System.out.println(base + &apos; raised to the power of &apos; + exponent + &apos; is: &apos; + result); } static double calculatePower(double base, int exponent) { double result = 1.0; while (exponent &gt; 0) { if ((exponent &amp; 1) == 1) { result *= base; } base *= base; exponent &gt;&gt;= 1; } return result; } } </pre> <p> <strong>Output:</strong> </p> <pre> 2.0 raised to the power of 5 is: 32.0 </pre> <hr></exponent;></pre></exponent;>

אופטימיזציה למעריכים של מספרים שלמים:

כאשר עוסקים במעריכים שלמים, אתה יכול לייעל את החישוב על ידי איטרציה רק ​​כמה פעמים כמו ערך המעריך. זה מקטין את מספר ההכפלות המיותרות.

PowerOfNumber6.java

משתמשי הצג mysql

 public class PowerOfNumber6 { public static void main(String[] args) { double base = 2.0; int exponent = 4; double result = calculatePower(base, exponent); System.out.println(base + &apos; raised to the power of &apos; + exponent + &apos; is: &apos; + result); } static double calculatePower(double base, int exponent) { double result = 1.0; for (int i = 0; i <exponent; i++) { result *="base;" } return result; < pre> <p> <strong>Output:</strong> </p> <pre> 2.0 raised to the power of 4 is: 16.0 </pre> <h3>5. Using Bit Manipulation to Calculate Binary Exponents:</h3> <p>Bit manipulation can be used to better improve integer exponents. To do fewer multiplications, an exponent&apos;s binary representation might be used.</p> <p> <strong>PowerOfNumber7.java</strong> </p> <pre> public class PowerOfNumber7 { public static void main(String[] args) { double base = 2.0; int exponent = 5; double result = calculatePower(base, exponent); System.out.println(base + &apos; raised to the power of &apos; + exponent + &apos; is: &apos; + result); } static double calculatePower(double base, int exponent) { double result = 1.0; while (exponent &gt; 0) { if ((exponent &amp; 1) == 1) { result *= base; } base *= base; exponent &gt;&gt;= 1; } return result; } } </pre> <p> <strong>Output:</strong> </p> <pre> 2.0 raised to the power of 5 is: 32.0 </pre> <hr></exponent;>

5. שימוש במניפולציית סיביות לחישוב אקספוננטים בינאריים:

ניתן להשתמש במניפולציה של סיביות כדי לשפר טוב יותר מעריכים שלמים. כדי לעשות פחות מכפלות, ניתן להשתמש בייצוג בינארי של מעריך.

PowerOfNumber7.java

 public class PowerOfNumber7 { public static void main(String[] args) { double base = 2.0; int exponent = 5; double result = calculatePower(base, exponent); System.out.println(base + ' raised to the power of ' + exponent + ' is: ' + result); } static double calculatePower(double base, int exponent) { double result = 1.0; while (exponent > 0) { if ((exponent & 1) == 1) { result *= base; } base *= base; exponent >>= 1; } return result; } } 

תְפוּקָה:

 2.0 raised to the power of 5 is: 32.0