Potegowanie rekurencyjne

0

Witam. Oto mój kod.

# include <iostream>
using namespace std;
long int pot(int b);
int a; 
int b; 
int main ()
    {
     cout<< podstawa:\t\t";
     cin>>a;
     cout<<"wykladnik:\t";
     cin>>b;
     cout<<"Wynik:\t\t\t"<<pot(b)<<endl<<endl;
     system("pause");
     return 0;
    }
    long int pot(int b)
     {
      if(b==0)
      return 1;
      else if (b<0)
      return 0;
      else     
      return pot(b-1)*a;
     }

Program działa bez problemu ale to nie wystarczy mojemu nauczycielowi. Błąd jaki mi wskazał jest taki, że używam zmiennej globalnej. Próbuje ale niestety nie wiem jak zmienić program w taki sposób aby nie używać już tej zmiennej globalnej.
Chodzi o tą cześć programu

long int pot(int b)
     {
      if(b==0)
      return 1;
      else if (b<0)
      return 0;
      else     
      return pot(b-1)*a;
     }

i przy wywoływaniu

cout<<"Wynik:\t\t\t"<<pot(b)<<endl<<endl; 

Jak można to przerobić? Pomóżcie!

0

Na przykład a i b zadeklarować lokalnie w mainie, a a przesyłać jako argument do tej funkcji

0

Jak to by wyglądało w kodzie? Bardziej rozumiem analizując kod programu niż opis.

0

Po prostu int b wrzuć do funkcji int main

0
# include <iostream>
using namespace std;
long int pot(int b);
int a;   //podstawa
int main (int b;)

i to wszystko?
Nauczyciel mówił mi, żebym coś takiego tu zrobił

long int pot(int x,y)
     {
      if(y==0)
      return 1;
      else if (y<0)
      return 0;
      else     
      return pot(x,y-1)*y;
     }
0

Normalne, powolne potęgowanie:

#include <iostream>

// wynik = r * a ^ b
int pow(int a, int b, int r) {
    return b == 0 ? r : pow(a, b - 1, r * a);
}

// wynik = a ^ b
int pow(int a, int b) {
    return pow(a, b, 1);
}

int main() {

    int a, b;

    std::cin >> a >> b;

    std::cout << pow(a, b);

    return 0;
}

Wersja z potęgowaniem szybkim:

#include <iostream>

// wynik = r * a ^ b
int fastpow(int a, int b, int r) {
    return b == 0 ? r : fastpow(a * a, b / 2, r * (b % 2 == 0 ? 1 : a));
}

// wynik = a ^ b
int fastpow(int a, int b) {
    return fastpow(a, b, 1);
}

int main() {

    int a, b;

    std::cin >> a >> b;

    std::cout << fastpow(a, b);

    return 0;
}

Obie wersje korzystają z rekurencji ogonowej, a więc kompilator rozwinie sobie tą rekurencję do zwykłej pętli (o ile oczywiście włączone są takie optymalizacje przy kompilacji).

0

Wibowit w jakim celu uzywasz zmiennej r ? Nie da rady zapisac potegowania w jednej funkcji tak jak ja to zrobilem? Bo twój program dzieli potęgowanie na dwie funkcje.Natomiast mój oblicza i zwraca wynik w jednej funkcji.

 return pot(b-1)*a;
0

Parametr r generalnie jest po to, aby umożliwić rekurencję ogonową. Można się obejść bez tego parametru, ale nie będzie się dało wtedy zrobić rekurencji ogonowej, tylko zwykłą.

0

Mam do wykonania zwykłą rekurencje.. Aby tylko bez zmiennej globalnej.

0

Pomoże ktoś? :(

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0