potegowanie

Witam mam oto taki problem, z potegami stykam się pierwszy raz, a także z funkcjami i nie wiem jak rozwiązać takie zadanie.

Napisz program obliczający potęgę "n"zadanej liczby "p"

Nie licze na rozwiązanei al ne jakieś podpowiedzi.

jeśli n jest liczbą całkowitą wywołaj mnożenie liczby p n razy w pętli :) np for.

Trochę koledzy mi pomogli ale udało się, tak przynajmniej mi się wydaje.

#include <stdio.h>
#include <conio.h>
#include <math.h>

int mojpow( int n, int p)
{
   
   int w, i;
   w=p;
   for( i=1; i<n; i++)
   w=w*p;
   if (n==0){
     w=1;
     }

   return w;

} 
 main() {
        int p, n;
        
        printf ("Podaj podstawe potegi: ");
        scanf ("%d", &p);
        printf ("Podaj potege: ");
        scanf ("%d", &n);
        printf ("%d do %d to %d", p, n, mojpow(n, p));
        getch();
        } //main

Trochę bardziej elegancko:

double pow(double liczba, int wykladnik)
{
  double mn = liczba;
  if(wykladnik == 0)
    return 1;
  for(int i=2;i<=wykladnik;i++)
    liczba*=mn;
  return liczba;
}

edit: dziekuje :P mała pomyłka :P

Zawsze można użyć biblioteki cmath ;)

pow(a,b)

http://www.cplusplus.com/reference/clibrary/cmath/pow/

#include <cstdio>
#include <cstdlib>

double potega(double liczba, int wykladnik) {

    double wynik = 1;
    for (; wykladnik > 0; wykladnik /= 2) {
        wynik *= wykladnik & 1 ? liczba : 1;
        liczba *= liczba;
    }
    return wynik;
}

int main() {

    printf("%f\n", potega(2.67, 9));

    return EXIT_SUCCESS;
}

Szybkie potęgowanie, log wykładnik kroków.

Shalom napisał(a)

Trochę bardziej elegancko:

double pow(double liczba, int wykladnik)
{
  if(wykladnik == 0)
    return 1;
  for(int i=2;i<=wykladnik;i++)
    liczba*=liczba;
  return liczba;
}

Chiba trochę kolegę poniosło :-)
Chociaż, w zasadzie to, działa gdy n<2.
Ma jeszcze jedną ciekawą właściwość, bardzo szybko liczy (liczba)⁽²wykładnik)
chyba nawet nie da się szybciej :-)

Jestem pełen podziwu. Zawsze jak myślę że nawet fajnie mi to wyszło to wy zawsze pokażecie mi że można jeszcze fajniej i krócej. Pełen szacunek.

double pow(double a, unsigned int n) {
    if (n==1) return a ;
    if (n==0) return 1;
    else if (n%2==0) return   pow(a*a, n/2);
    else             return a*pow(a*a,(n-1)/2);}

double pow(double a, unsigned int n) {
    return n==1?a:n==0?1:pow(a*a, (n - n%2)/2);
}

Brzydkie jak cholera ale powinno działać jak powyższe (nie wiem czy dobrze). Jeśli chodzi o zapis to krócej się chyba już nie da.

//EDIT: @down teraz lepiej?

winerstinks:
twoje rozwiązanie nie działa dobrze. Coś w ten deseń działa:

double pow(double a, unsigned int n) {
    return n ? (n & 1 ? a : 1) * pow(a * a, n / 2) : 1;
}

edit:
co lepiej? testowałeś ten swój kod?

http://pl.wikipedia.org/wiki/Potęgowanie

x^y=exp(y*ln(x)) dla odpowiednich zalozen wzgledem x (x>0)

y = y

| 1 = ln(x) / ln(x) | x>0

y = y
y * ln(x) = y * ln(x) | prawa strona a*ln(b) = ln(b^a)
y * ln(x) = ln(x^y)

| 1 = ln(e)

1 * y * ln(x) = ln(x^y)
ln(e) * y * ln(x) = ln(x^{y) | lewa strona aln(b) = ln(b}a) , gdzie a=yln(x) , ln(b)=ln(e)
ln( e ^{(y*ln(x) ) = ln (x}y) | zdejmujemy logarytm

e^(y*ln(x))=xy , x>0

Flabra:
Liczenie z tego wzoru nadaje się chyba tylko do wykładników niecałkowitych. Tzn wg mnie potęgowanie szybkie powinno być szybsze.