Hoe doe je machtsverheffen in C?

Ik heb “x = y ** e” geprobeerd, maar dat werkte niet.

Antwoord 1, autoriteit 100%

gebruik de functie pow(er zijn echter floats/doubles nodig).

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: voor het speciale geval van positieve gehele machten van 2, kunt u bitverschuiving gebruiken: (1 << x)is gelijk aan 2tot de macht x. Er zijn enkele mogelijke problemen hiermee, maar over het algemeen zou het correct zijn.

Antwoord 2, autoriteit 35%

Om toe te voegen aan wat Evanzei: C doet hebben geen ingebouwde operator voor machtsverheffing, omdat het voor de meeste CPU’s geen primitieve bewerking is. Het is dus geïmplementeerd als een bibliotheekfunctie.

Voor het berekenen van de functie e^x kunt u ook de exp(double), expf(float)en expl(long double)functies.

Houd er rekening mee dat u geende operator ^wilt gebruiken, de operator exclusief bitsgewijze OR.

Antwoord 3, autoriteit 25%

powwerkt alleen op getallen met drijvende komma (eigenlijk doubles). Als je machten van gehele getallen wilt nemen, en het grondtal staat niet bekend als een exponent van 2, dan moet je die van jezelf werpen.

Meestal is de domme manier goed genoeg.

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

Hier is een recursieve oplossing die O(log n)ruimte en tijd in beslag neemt in plaats van de gemakkelijke O(1)spatie O(n)tijd:

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

Antwoord 4, autoriteit 6%

Vergelijkbaar met een eerder antwoord, zal dit goed omgaan met positieve en negatieve gehele machten van een dubbel.

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

Antwoord 5, autoriteit 5%

De niet-recursieve versie van de functie is niet al te moeilijk – hier is het voor gehele getallen:

long powi(long x, unsigned n)
{
    long p = x;
    long r = 1;
    while (n > 0)
    {
        if (n % 2 == 1)
            r *= p;
        p *= p;
        n /= 2;
    }
    return(r);
}

(Gehackt uit code voor het verhogen van een dubbele waarde tot een geheel getal – moest bijvoorbeeld de code verwijderen om met reciprocals om te gaan.)

Antwoord 6, autoriteit 2%

of je zou gewoon de power-functie kunnen schrijven, met recursie als toegevoegde bonus

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

ja, ja ik weet dat dit minder efficiënte ruimte- en tijdcomplexiteit is, maar recursie is gewoon leuker!!

Antwoord 7, Autoriteit 2%

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

(iteratief)

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

(als het opnieuw moet zijn)

IMO, het algoritme moet zeker o (logn)

zijn