Расчет степеней целых чисел

Ответ 1

Целые числа - только 32 бита. Это означает, что его максимальное значение составляет 2^31 -1. Как видите, для очень маленьких чисел у вас быстро получается результат, который больше не может быть представлен целым числом. Вот почему Math.pow использует double.

Если вам нужна произвольная целочисленная точность, используйте BigInteger.pow. Но это, конечно, менее эффективно.

Ответ 2

Лучший алгоритм основан на определении рекурсивной мощности a ^ b.

long pow (long a, int b)
{
    if ( b == 0)        return 1;
    if ( b == 1)        return a;
    if (isEven( b ))    return     pow ( a * a, b/2); //even a=(a^2)^b/2
    else                return a * pow ( a * a, b/2); //odd  a=a*(a^2)^b/2

}

Продолжительность операции - O (logb). Ссылка: Дополнительная информация

Ответ 3

Нет, нет ничего короткого, как a**b

Вот простой цикл, если вы хотите избежать двойников:

long result = 1;
for (int i = 1; i <= b; i++) {
   result *= a;
}

Если вы хотите использовать pow и преобразовать результат в integer, произведите результат следующим образом:

int result = (int)Math.pow(a, b);

Ответ 4

Google Guava имеет математические утилиты для целых чисел. IntMath

Ответ 5

Когда это сила 2. Имейте в виду, что вы можете использовать простое и быстрое выражение сдвига 1 << exponent

пример:

2 ²= 1 << 2= (int) Math.pow(2, 2)
2 ¹⁰= 1 << 10= (int) Math.pow(2, 10)

Для более крупных показателей (более 31) используйте long

2 ³²= 1L << 32= (long) Math.pow(2, 32)

Кстати. в котлине у тебя shl вместо << так

(Java) 1L << 32= 1L shl 32 (Котлин)

Ответ 6

Ну, вы можете просто использовать Math.pow(a,b), как вы использовали ранее, и просто преобразовать его значение, используя (int) перед ним. Ниже может быть использован в качестве примера.

int x = (int) Math.pow(a,b);

где a и b могут быть double или int значения по вашему желанию. Это просто преобразует его вывод в целочисленное значение по мере необходимости.

Ответ 7

Математические библиотеки Guava предлагают два метода, которые полезны при вычислении точных целых степеней:

pow(int b, int k) вычисляет b к kth мощности и обертывает переполнение

checkedPow(int b, int k) идентичен, за исключением того, что он перебрасывает ArithmeticException при переполнении

Лично checkedPow() удовлетворяет большинство моих потребностей для целочисленного возведения в степень и является более чистым и безопасным, чем использование двойных версий и округления и т.д. Почти во всех местах, где я хочу функцию мощности, переполнение является ошибкой (или невозможной, но Я хочу, чтобы мне сказали, если невозможное когда-нибудь станет возможным).

Если вы хотите получить результат long, вы можете просто использовать соответствующие методы LongMath и передать аргументы int.

Ответ 8

import java.util.*;

public class Power {

    public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        int num = 0;
        int pow = 0;
        int power = 0;

        System.out.print("Enter number: ");
        num = sc.nextInt();

        System.out.print("Enter power: ");
        pow = sc.nextInt();

        System.out.print(power(num,pow));
    }

    public static int power(int a, int b)
    {
        int power = 1;

        for(int c = 0; c < b; c++)
            power *= a;

        return power;
    }

}

Ответ 9

Мне удалось изменить (границы, даже проверить, отрицательная проверка количества) Qx__ answer. Используйте на свой риск. 0 ^ -1, 0 ^ -2 и т.д. Возвращает 0.

private static int pow(int x, int n) {
        if (n == 0)
            return 1;
        if (n == 1)
            return x;
        if (n < 0) { // always 1^xx = 1 && 2^-1 (=0.5 --> ~ 1 )
            if (x == 1 || (x == 2 && n == -1))
                return 1;
            else
                return 0;
        }
        if ((n & 1) == 0) { //is even 
            long num = pow(x * x, n / 2);
            if (num > Integer.MAX_VALUE) //check bounds
                return Integer.MAX_VALUE; 
            return (int) num;
        } else {
            long num = x * pow(x * x, n / 2);
            if (num > Integer.MAX_VALUE) //check bounds
                return Integer.MAX_VALUE;
            return (int) num;
        }
    }

Ответ 10

Простая (нет проверки на переполнение или допустимость аргументов) для алгоритма повторного квадратирования для вычисления мощности:

/** Compute a**p, assume result fits in a 32-bit signed integer */ 
int pow(int a, int p)
{
    int res = 1;
    int i1 = 31 - Integer.numberOfLeadingZeros(p); // highest bit index
    for (int i = i1; i >= 0; --i) {
        res *= res;
        if ((p & (1<<i)) > 0)
            res *= a;
    }
    return res;
}

Сложность времени логарифмична по экспоненте p (т.е. линейная по отношению к числу битов, необходимых для представления p).

Ответ 11

В отличие от Python (где мощности могут быть вычислены с помощью ** b), JAVA не имеет такого быстрого пути для достижения результата мощности двух чисел. Java имеет функцию с именем pow в классе Math, которая возвращает двойное значение

double pow(double base, double exponent)

Но вы также можете вычислить степень целого с использованием той же функции. В следующей программе я сделал то же самое, и, наконец, я преобразовал результат в целое число (typecasting). Следуйте примеру:

import java.util.*;
import java.lang.*; // CONTAINS THE Math library
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n= sc.nextInt(); // Accept integer n
        int m = sc.nextInt(); // Accept integer m
        int ans = (int) Math.pow(n,m); // Calculates n ^ m
        System.out.println(ans); // prints answers
    }
}

В качестве альтернативы, java.math.BigInteger.pow(int exponent) возвращает значение BigInteger, значение которого (this ^ exponent). Показатель представляет собой целое число, а не BigInteger. Пример:

import java.math.*;
public class BigIntegerDemo {
public static void main(String[] args) {
      BigInteger bi1, bi2; // create 2 BigInteger objects          
      int exponent = 2; // create and assign value to exponent
      // assign value to bi1
      bi1 = new BigInteger("6");
      // perform pow operation on bi1 using exponent
      bi2 = bi1.pow(exponent);
      String str = "Result is " + bi1 + "^" +exponent+ " = " +bi2;
      // print bi2 value
      System.out.println( str );
   }
}

Ответ 12

Используйте приведенную ниже логику для вычисления n-степени a.

Обычно, если мы хотим вычислить мощность n. Мы умножим "a" на n раз. Сложность этого подхода будет O (n). Разделите мощность n на 2, вычислите Exponentattion = multiply "a" только до n/2. Удвойте значение. Теперь Сложность Времени уменьшена до O (n/2).

public  int calculatePower1(int a, int b) {
    if (b == 0) {
        return 1;
    }

    int val = (b % 2 == 0) ? (b / 2) : (b - 1) / 2;

    int temp = 1;
    for (int i = 1; i <= val; i++) {
        temp *= a;
    }

    if (b % 2 == 0) {
        return temp * temp;
    } else {
        return a * temp * temp;
    }
}

Ответ 13

base это число, которое вы хотите включить, n это мощность, мы возвращаем 1, если n равно 0, и мы возвращаем base, если n равно 1, если условия не выполняются, мы используем формулу base * (powerN (base, n-1)) напр.: 2 для использования по этой формуле: 2 (base) * 2 (powerN (base, n-1)).

public int power(int base, int n){
   return n == 0 ? 1 : (n == 1 ? base : base*(power(base,n-1)));
}