Как вы делаете возведение в степень в C?

Ответ 1

используйте функцию pow (требуется float s/double).

man pow:

   #include <math.h>

   double pow(double x, double y);
   float powf(float x, float y);
   long double powl(long double x, long double y);

EDIT: BTW, для частного случая положительных целых степеней 2, вы можете использовать смещение бит: (1 << x) будет равно 2 мощности x. Есть некоторые потенциальные проблемы с этим, но в целом это было бы правильно.

Ответ 2

Чтобы добавить к тому, что Evan сказал: C не имеет встроенного оператора для возведения в степень, потому что это не примитивная операция для большинства процессоров. Таким образом, он реализован как библиотечная функция.

Кроме того, для вычисления функции e ^ x вы можете использовать функции exp(double), expf(float) и expl(long double).

Обратите внимание, что вы не хотите использовать оператор ^, который является побитовым эксклюзивным оператором OR.

Ответ 3

pow работает только с числами с плавающей запятой (double s, на самом деле). Если вы хотите взять полномочия целых чисел, а база не известна как показатель степени 2, вам придется сворачивать свои собственные.

Обычно тупой путь достаточно хорош.

int power(int base, unsigned int exp) {
    int i, result = 1;
    for (i = 0; i < exp; i++)
        result *= base;
    return result;
 }

Здесь рекурсивное решение, которое занимает O(log n) пространство и время вместо простого O(1) space O(n) time:

int power(int base, int exp) {
    if (exp == 0)
        return 1;
    else if (exp % 2)
        return base * power(base, exp - 1);
    else {
        int temp = power(base, exp / 2);
        return temp * temp;
    }
}

Ответ 4

Подобно более раннему ответу, это будет обрабатывать положительные и отрицательные целые степени двойного красиво.

double intpow(double a, int b)
{
  double r = 1.0;
  if (b < 0)
  {
    a = 1.0 / a;
    b = -b;
  }
  while (b)
  {
    if (b & 1)
      r *= a;
    a *= a;
    b >>= 1;
  }
  return r;
}

Ответ 5

Нерекурсивная версия функции не слишком сложна - здесь она предназначена для целых чисел:

long powi(long x, unsigned n)
{
    long  p;
    long  r;

    p = x;
    r = 1.0;
    while (n > 0)
    {
        if (n % 2 == 1)
            r *= p;
        p *= p;
        n /= 2;
    }

    return(r);
}

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

Ответ 6

int power(int x,int y){
 int r=1;
 do{
  r*=r;
  if(y%2)
   r*=x;
 }while(y>>=1);
 return r;
};

(итеративный)

int power(int x,int y){
 return y?(y%2?x:1)*power(x*x,y>>1):1;
};

(если он должен быть рекурсивным)

imo, алгоритм должен определенно быть O (logn)

Ответ 7

или вы можете просто написать функцию питания, с рекурсией в качестве дополнительного бонуса

int power(int x, int y){
      if(y == 0)
        return 1;
     return (x * power(x,y-1) );
    }

да, да, я знаю, что это менее эффективная пространственная и временная сложность, но рекурсия просто веселее!

Ответ 8

вот как - http://algohub.blogspot.com/2014/04/exponentiation.html

его алгоритм деления и покорения. Вставьте его на более мелкие части, пока он не станет жевательным и не разрешит его, а затем используйте этот результат меньшей проблемы, чтобы постепенно наращивать решение для решения больших проблем, пока не решите проблему для заданный вход

его прямо... я знаю, если у вас есть вопросы