Algorytmy maturalne -część pierwsza

Zawartość
Fibonacci iteracyjnie ................................................................................................................................ 2
Fibonacci rekurencyjnie........................................................................................................................... 2
NWD iteracyjnie poprzez odejmowanie.................................................................................................. 2
NWD rekurencyjnie poprzez odejmowanie ............................................................................................ 2
NWD iteracyjnie poprzez dzielenie ......................................................................................................... 3
NWD rekurencyjnie dzielenie .................................................................................................................. 3
Opisz samodzielnie .................................................................................................................................. 3
Potęga iteracyjnie .................................................................................................................................... 4
Potęga rekurencyjnie............................................................................................................................... 4
Potęga iteracyjnie – szybkie potęgowanie .............................................................................................. 4
Potęga rekurencyjnie – szybkie potęgowanie ......................................................................................... 4
Silnia iteracyjnie ...................................................................................................................................... 5
Silnia rekurencyjnie ................................................................................................................................. 5
Czy pierwsza iteracyjnie .......................................................................................................................... 5
Sito Eratostenesa ..................................................................................................................................... 6
Dzielniki powoli a dokładnie .................................................................................................................... 6
Dzielniki trochę szybciej .......................................................................................................................... 6
Dzielniki szybko ale niedokładnie ............................................................................................................ 6
Rozkład liczby na czynniki pierwsze ........................................................................................................ 7
Rozkład liczby na cyfry iteracyjnie ........................................................................................................... 7
Rozkład liczby na cyfry rekurencyjnie...................................................................................................... 7
Zmiana systemu z DEC na inny o podstawie p (1<p<10) ......................................................................... 7
Wyszukiwanie binarne ............................................................................................................................ 8
Fibonacci iteracyjnie
void f(int n)
{
long long a = 0, b = 1;

for(int i=0;i<n;i++)
{
cout<<b<<" ";
b += a;
a = b-a;
}
}

Fibonacci rekurencyjnie
int f(int n)
{
if(n<3)
return 1;

return f(n-2)+f(n-1);
}

NWD iteracyjnie poprzez odejmowanie

int f(int a, int b)
{
while(a!=b)
if(a>b)
a-=b; //lub a = a - b;
else
b-=a; //lub b = b-a
return a; // lub b - zmienne są równe
}

NWD rekurencyjnie poprzez odejmowanie

int f(int a, int b)
{ if(a!=b)
return NWD(a>b?a-b:a,b>a?b-a:b);
return a;
}
NWD iteracyjnie poprzez dzielenie
int f(int a, int b)
{
int pom;
while(b!=0)
{ pom = b;
b = a%b;
a = pom;
}
return a;
}

NWD rekurencyjnie dzielenie

int f(int a, int b)
{
if(b!=0)
return f(b,a%b);

return a;
}

Opisz samodzielnie
int f(int a, int b)
{
while(b)
swap(a %= b, b);
return a;
}
Potęga iteracyjnie
int f(int a,int b)
{
int w=1;
while(b--)
w*=a;
return w;
}

Potęga rekurencyjnie
int f(int a,int b)
{
if (b==0)return 1;
return a*f(a,--b);
}

Potęga iteracyjnie – szybkie potęgowanie

long long f(long long a, unsigned int n)
{
long long w = 1;
while(n>0)
{
if (n%2) //jesli bit jest = 1
w *= a;
a*= a;
n/=2; //skrócenie o jeden bit, można zastąpić przesunięciem bitowym
}
return w;
}

Potęga rekurencyjnie – szybkie potęgowanie

long long f(long long a, unsigned int n)
{
if(n==0)
return 1;

if(n%2 == 1) //gdy n jest nieparzyste

return a * f(a, n - 1);
long long w = f(a, n/2);
return w * w;
}
Silnia iteracyjnie
int f(int a,int n)
{ int w;
if (n == 0) return 1;
while (n)
{
w *= n;
n--;
}
return w;
}

Silnia rekurencyjnie
int f(int n)
{
if(n<2) return 1;
return n*f(n-1);
}

Czy pierwsza iteracyjnie

bool f(int n)
{
if(n<2)
return false; //gdy liczba jest mniejsza niż 2 to nie jest pierwszą

for(int i=2;i*i<=n;i++)
if(n%i==0)
return false; //gdy znajdziemy dzielnik, to dana liczba nie jest
pierwsza
return true;
}
Sito Eratostenesa
void f(bool *tab, unsigned int n)
{
for (int i=2; i*i<=n; i++) //przeszukujemy kolejnych kandydatów na pierwsze
{ //wystarczy sprawdzić do pierwiastka z n
// i<=sqrt(n) - podnosząc do kwadratu mamy
// i*i <= n
if(!tab[i]) //jesli liczba jest pierwsza(ma wartosc 0)
for (int j = i*i ; j<=n; j+=i) //to wykreslamy jej wielokrotnosci
tab[j] = 1; //ustawiając wartosć na 1
}
}

Dzielniki powoli a dokładnie

void f(int n)
{
for(int i=1; i<=n; i++)
{
if(n % i == 0)
cout << i << endl;
}
}

Dzielniki trochę szybciej

void f(int n)
{
for(int i=1; i<=n/2; i++)
{
if(n % i == 0)
cout << i << endl;
}
cout << n;
}

Dzielniki szybko ale niedokładnie

void f(int n)
{ cout << 1 <<' '<< n << endl;
for(int i=2;i*i<n;i++)
if(n%i==0) cout << i <<' '<< n/i << endl;

//czasami jednego brakuje – popraw kod

}
Rozkład liczby na czynniki pierwsze
void f(int n)
{
int k=2; //ustawiamy k na pierwszą liczbę pierwszą
while(n>1)
{
while(n%k==0) //dopóki liczba jest podzielna przez k
{
cout<<k<<" ";
n/=k;
}
++k;
}
}

Rozkład liczby na cyfry iteracyjnie

void f(int n)
{ int a;
while(n!=0)
{
a = n % 10;

cout<<a<<' '; // otrzymamy zapis w kolejności odwrotnej

n = n/10;
}
}

Rozkład liczby na cyfry rekurencyjnie

void f(int n)
{
if(n>9) f(n/10);
cout<<n%10<<' ';
}

Zmiana systemu z DEC na inny o podstawie p (1<p<10)

void f(int n, int p)
{
if (n>1) f(n/p, p);
cout<<n%p;
}
Wyszukiwanie binarne
int tab[n] //tablica uporządkowana niemalejąco o n elementach
int f(int l, int p, int x)
{
int sr;
while(l<=p)
{
sr = (l + p)/2;

if(tab[sr] == x)
return sr; //zwracamy indeks znalezionego elementu

if(tab[sr] > x)
p = sr - 1;
else
l = sr + 1;
}

return -1; //zwracamy -1, gdy nie znajdziemy elementu

}