Algorytmy napisane w C++

Algorytm mnożenia dwóch liczb nieujemnych całkowitych przy pomocy dodawania

//----------------------

#include <cstdlib>

#include <iostream>

//-----------------------

using namespace std;

int main(int argc, char *argv[])

{

int plus(int, int);

unsigned a;

unsigned b;

cout << "Algorytm mnożenia dwóch liczb"

"nieujemnych całkowitych przy pomocy dodawania\n\n";

cout << "podaj a: ";

cin >> a;

cout << "podaj b: ";

cin >> b;

cout << "a*b= " << plus(a,b) << "\n\n";

system("PAUSE");

return EXIT_SUCCESS;

}

//-------------------------

int plus(int a, int b)

{

int i;

int temp = a;

for(i=1;i<b;i++)

a+=temp;

return a;

}

Algorytm obliczania n-tego wyrazu ciągu Fibonacciego

//-----------------------

#include <cstdlib>

#include <iostream>

//------------------------

using namespace std;

int fib(int);

int main(int argc, char* argv[])

{

int n;

cout << "Podaj pozycje szukanego wyrazu: ";

cin >> n;

cout << "\nWartosc elementu nr " << n << " wynosi " << fib(n) << "\n";

system("PAUSE");

return EXIT_SUCCESS;

}

//---------------------------------------------------------------------------

int fib(int n)

{

if(n==0)

return 0;

else

if(n==1)

return 1;

else

return fib(n-2)+fib(n-1);

}

Algorytm znajdujacy minimum i maksimum

//------------------------------------------

#include <cstdlib>

#include <iostream>

# define n 25

using namespace std;

int main(int argc, char *argv[])

{

int t[n];

int i;

cout<<"Algorytm znajdujacy minimum i maksimum"<<endl;

srand((unsigned int)time(NULL));

for (i=0; i<n; i++)

{

t[i]=rand() %25+1; //ograniczenie do 30

cout<<t[i]<<" ";}

cout<<"\n\n";

int min=t[0];

int max=t[0];

for(i=0; i<n; i++)

{

if (min>t[i]) min=t[i];

if (max<t[i]) max=t[i];

}

cout<<"Minimum wynosi "<<min<<endl;

cout<<"Maksimum wynosi "<<max<<endl;

system("PAUSE");

return EXIT_SUCCESS;

}

Algorytm dzielenia z resztą dwóch liczb całkowitych nieujemnej przez dodatnią przy pomocy odejmowania

//------------------------

#include <cstdlib>

#include <iostream>

//-------------------------

using namespace std;

int main(int argc, char *argv[])

{

unsigned a;

unsigned b;

int i=0;

cout << "Algorytm dzielenia z resztą dwóch liczb całkowitych "

"(nieujemnej przez dodatnią) przy pomocy odejmowania\n\n";

cout << "podaj a: ";

cin >> a;

cout << "podaj b: ";

cin >> b;

if(b==0)

cout << "\nNie nauczyli Cie ze sie nie dzieli przez zero???\n\n";

else

{

while(a>=b)

{

a-=b;

i++;

}

cout << "a / b = " << i << ", natomiast reszta = " << a%b << "\n\n";

}

system("PAUSE");

return EXIT_SUCCESS;

}

Algorytm obliczania wartości wielomianu n-tego stopnia wg schematu Hornera

//---------------------------------------------------------------------------

#include <cstdlib>

#include <iostream>

//---------------------------------------------------------------------------

using namespace std;

int main(int argc, char *argv[])

{

int x;

int a[20];

int n;

int i,s;

cout << "Algorytm obliczania wartości wielomianu n-tego "

"stopnia wg schematu Hornera\n";

cout << "\nPodaj najwyzsza potege wielomianu: ";

cin >> n;

for(i=0;i<=n;i++)

{

cout << "\nPodaj a" << i << " :\n";

cin >> a[i];

}

cout << "\n\nPodaj wartosc x: ";

cin >> x;

s=a[0];

for(i=1;i<=n;i++)

{

s=s*x+a[i];

}

cout << "\n\nWartosc tego wielomianu: " << s << "\n\n";

system("PAUSE");

return EXIT_SUCCESS;

}

Algorytm znajdowania NWP

//-----------------------

#include <cstdlib>

#include <iostream>

//-------------------------

using namespace std;

int main(int argc, char *argv[])

{

int a;

int b;

cout << "Algorytm znajdowania NWP(a,b): \n";

cout << "podaj a: ";

cin >> a;

cout << "podaj b: ";

cin >> b;

if(a==0 || b==0)

cout << "\nNWP(a,b) = 0\n";

else

{

while(a!=b)

{

if(a>b)

a-=b;

else if(a<b)

b-=a;

}

cout << "\nNWP(a,b) = \n" << a;

}

system("PAUSE");

return EXIT_SUCCESS;

}

Algorytm sprawdzający czy ciąg liczb a1,..., an jest uporządkowany

//---------------------------------------------------------------------------

#include <cstdlib>

#include <iostream>

using namespace std;

int main(int argc, char *argv[])

{

int t[]={11,11,11,11,10,7,6,5,4,3};

int a;

int z=0;

int i=0;

int n=10; //ilosc liczb w ciagu

for(i;i<n;i++)

{

if(t[i]>t[i+1])break; a=1;

if(t[i]<t[i+1])break; a=2;

}

if(a==1)

{

for(i;i<n;i++)

{if(t[i]>=t[i+1]) break;}}

if(a==2)

{

for(i;i<n;i++)

{if(t[i]<=t[i+1]) break;}}

if(i>=n-1) z=1;

if(z==1 && a==1) cout<<"Ciag jest rosnacy"<<endl;

if(z==1 && a==2) cout<<"Ciag jest malejacy"<<endl;

if(z==0) cout<<"Ciag nie jest uporzadkowany";

system("PAUSE");

return EXIT_SUCCESS;

}

Sortowanie przez proste wyszukiwanie:

//---------------------------------------------------------------------------

#include <cstdlib>

#include <iostream>

# define n 100

using namespace std;

int main(int argc, char* argv[])

{

cout<<"sortowanie przez proste wyszukiwanie"<<endl<<endl;

int t[n];

int i;

srand((unsigned int)time(NULL));

for(i=0;i<n;i++)

{

t[i]=rand() %100+1;

cout<<t[i]<<" ";

if ((i+1)%10==0) cout<<endl;}

cout<<endl<<endl;

for(i=0;i<n-1;i++)

{

int ix=i;

for(int j=i+1;j<n;j++)

if(t[j]<t[ix])

ix=j;

int temp=t[ix];

t[ix]=t[i];

t[i]= temp;

}

for(i=0;i<n;i++)

{cout<<t[i]<<" ";

if ((i+1)%10==0) cout<<endl;}

cout<<endl;

system("PAUSE");

return EXIT_SUCCESS;

}

Algorytm odwracania kolejności elementów w ciągu a1,..., an

//-----------------------

#include <cstdlib>

#include <iostream>

# define n 25

//----------------------

using namespace std;

int main(int argc, char* argv[])

{

int t[n];

int x;

int i;

cout << "Algorytm odwracania kolejności elementów w "

"ciągu a1,..., an\n\n";

srand((unsigned int)time(NULL));

for(x=0;x<n;x++)

{

t[x]=rand() %25+1; //ograniczenie do 30

cout<<t[x]<<" ";

}

cout<<"\n\n";

for(x=0;x<(n/2);x++)

{

i=t[x];

t[x]=t[(n-1-x)];

t[(n-1-x)]=i;

}

for(x=0;x<n;x++)

{

cout<<t[x]<<" ";

}

getchar();

system("PAUSE");

return EXIT_SUCCESS;

}

Algorytm podajacy liczbe wystapien k w ciagu

//---------------------

#include <cstdlib>

#include <iostream>

# define n 25

using namespace std;

int main(int argc, char *argv[])

{

int a;

int b=0;

int t[n];

int i=0;

cout<<"Algorytm podajacy liczbe wystapien danej liczby w ciagu (losowym)\n";

cout<<"Podaj liczbe ";

cin>>a;

cout<<"\n";

srand((unsigned int)time(NULL));

for (i=0;i<n;i++)

{

t[i]=rand() %25+1; //ograniczenie do 30

cout<<t[i]<<" ";

}

cout<<"\n\n";

for(i=0;i<n;i++)

{

if (t[i]==a)

b++;

}

cout<<a<<" wystepuje w ciagu "<<b<<" razy ";

system("PAUSE");

return EXIT_SUCCESS;

}

Algorytm wyszukiwania polowkowego

//---------------------------------------------------------------------------

#include <cstdlib>

#include <iostream>

# define n 10

//---------------------------------------------------------------------------

using namespace std;

int main(int argc, char* argv[])

{

int t[n]={1,2,3,5,6,7,8,9,14,19};

int min=0;

int max=n-1;

int f;

int x;

int i;

int v=0;

cout << "Algorytm wyszukiwania polowkowego\n\n";

for(i=0; i<n; i++)

cout << t[i] << " ";

cout << "\n\nPodaj liczbe ktorej szukasz: ";

cin >> x;

while(v==0 && (min<=max))

{

f=(min + max)/2;

if(x > t[f-1])

min = f + 1;

if(x < t[f-1])

max = f - 1;

if(x == t[f-1])

v=1;

}

if(v==1)

cout << "\nSzukana liczba znajduje sie na pozycji " << f << "\n";

else

cout << "\nSzukana liczba nie wystepuje\n";

system("PAUSE");

return EXIT_SUCCESS;

}

Algorytm znajdowania sumy podzielników danej liczby

//-------------------------

#include <cstdlib>

#include <iostream>

//------------------------

using namespace std;

int main(int argc, char *argv[])

{

int x;

int i;

int wyn=0;

cout << "Algorytm znajdowania sumy podzielników danej liczby \n\n"

"Podaj liczbe: ";

cin >> x;

for(i=1;i<=x;i++)

if(x%i==0)

wyn+=i;

cout << "\nSuma podzielnikow a = " << wyn << "\n\n";

system("PAUSE");

return EXIT_SUCCESS;

}

Algorytm podający, dla których spośród liczb a1,..., an liczba k jest podzielnikiem

//-----------------------

#include <cstdlib>

#include <iostream>

//-----------------------

using namespace std;

int main(int argc, char *argv[])

{

unsigned k;

int i;

unsigned n;

cout << "Algorytm podający, dla których spośród liczb "

"a1,..., an liczba k jest podzielnikiem\n\n";

cout << "Podaj zakres ciagu a1,..., an czyli n: ";

cin >> n;

cout << "\n\nPodaj podzielnik: ";

cin >> k;

for(i=1; i<=n; i++)

{

if(i%k==0)

cout << "\nLiczba " << k << " jest podzielnikiem " << i << "\n";

}

system("PAUSE");

return EXIT_SUCCESS;

}

Sortowanie babelkowe

//---------------------------------------------------------------------------

#include <cstdlib>

#include <iostream>

# define n 25

//---------------------------------------------------------------------------

using namespace std;

int main(int argc, char *argv[])

{

int t[n];

int i;

int j;

int x;

cout << "Sortowanie babelkowe\n\n";

srand((unsigned int)time(NULL));

for(i=0;i<n;i++)

{

t[i]=rand() %25+1; //ograniczenie do 30

cout<<t[i]<<" ";

}

cout<<"\n\n";

for(i=0;i<n-1;i++)

for(j=n-1;j>i;j--)

{

if(t[i] > t[j])

{

x=t[i];

t[i]=t[j];

t[j]=x;

}

cout << "\n\n";

for(i=0;i<n;i++)

cout<<t[i]<<" ";

cout << "\n\n";

system("PAUSE");

return EXIT_SUCCESS;

}

Algorytm znajdowania liczb pierwszych metodą sita Eratostenesa

//---------------------------------------------------------------------------

#include <iostream>

#include <iomanip>

using namespace std;

main()

{

const unsigned MAX_LP = 1000000; // maksymalna długość zbioru

bool t[MAX_LP + 1];

unsigned i,w,g;

char s[1];

cout << "Wyszukiwanie liczb pierwszych sitem Eratostenesa\n"

"Podaj granice = ";

cin >> g; cout << endl;

if(g > MAX_LP)

cout << "Granica zbyt wielka\n";

else

{

for(i = 2; i <= g; i++) t[i] = true;

for(i = 2; i <= g; i++)

{

w = i + i;

while(w <= g)

{

t[w] = false; w += i;

}

for(i = 2; i <= g; i++)

if(t[i]) cout << setw(10) << i;

cout << endl;

}

cout << "\n\nKlawisz Enter = KONIEC";

cin.getline(s,1);

}

PROSTE WSTAWIANIE

#include <cstdlib>

#include <iostream>

#include <stdlib.h>

#include <time.h>

#define MAX 50

using namespace std;

int main(int argc, char *argv[])

{

int tab[MAX] = {0};

srand((unsigned)time(NULL));

for(int i = 0; i < MAX; i++)

tab[i] = rand()%MAX + 1;

int tmp = 0;

for(int i = 1, j; i < MAX; i++)

{

tmp = tab[i];

for(j = i; j > 0 && tmp < tab[j-1]; j--)

tab[j] = tab[j-1];

tab[j] = tmp;

}

for(int i = 0; i < MAX; i++)

{

cout << tab[i] << ' ';

if(!((i+1)%10))

cout << endl;

}

system("PAUSE");

return EXIT_SUCCESS;

}

23 BISEKCJA

double f(double x)

{

return 2*x;

}

double a, b, x0, fa, fb, f0;

fa = f(a);

fb = f(b);

if(fa*fb > 0) cout << "Funkcja nie spelnia zalozen!" << endl;

else

while(fabs(a-b) > EPSX)

{

x0 = (a+b)/2;

f0 = f(x0);

if(fabs(f0) < EPS0) break;

if(fa * f0 < 0) b = x0;

else

{

a = x0;

fa = f0;

}

cout << "x0 = " << x0 << endl;

20 ALGORYTM OBLICZANIA WYZNACZNIKA MACIERZY O TRZECH WIERSZACH I 3 KOLUMNACH

#include <iostream>

#include <stdlib.h>

#include <cstdlib>

#include <time.h>

#define W1 3

#define K1 3

using namespace std;

int main(int argc, char *argv[])

{

int i=0;

int j=0;

int wyz=1;

int t[W1][K1]={{1,-1,0},{0, 1, 1},{1,1,-1} };

for(i=0;i<W1;i++)

{

for(j=0;j<K1;j++)

cout<<t[i][j]<<" ";

cout<<endl;

}

wyz=t[0][0]*t[1][1]*t[2][2] + t[1][0]*t[2][1]*t[0][2]+ t[2][0]*t[0][1]*t[1][2];

wyz-=(t[0][2]*t[1][1]*t[2][0]+t[1][2]*t[2][1]*t[0][0]+ t[2][2]*t[0][1]*t[1][0]);

cout<<wyz;

cout<<endl;

system("PAUSE");

return 0;

}

21ALGORYTM OBLICZAJACY SRENIE ARYTMETYCZNE POSZCZEGOLNYCH KOLUMN

#include <iostream>

#include <stdlib.h>

#include <cstdlib>

#include <time.h>

#define W1 4

#define K1 3

using namespace std;

int main(int argc, char *argv[])

{

int i=0;

int j=0;

double sr=0;

double sr1=0;

double sr2=0;

int suma=0;

int t[W1][K1]={{5,5,0},{5,1,1},{5,1,-1},{5,3,3} };

for(i=0;i<W1;i++)

{

for(j=0;j<K1;j++)

cout<<t[i][j]<<" ";

cout<<endl;

}

for(i=0;i<K1;i++)

{

for(j=0;j<W1;j++)

{

sr=sr+t[j][i];

sr1+=t[j][i+1];

sr2+=t[j][i+2];

}

break;

}

sr=sr/W1;

sr1=sr1/W1;

sr2=sr2/W1;

cout<<"srednia arytmetyczna 1 kolumny to "<<sr<<endl;

cout<<"srednia arytmetyczna 2 kolumny to "<<sr1<<endl;

cout<<"srednia arytmetyczna 3 kolumny to "<<sr2<<endl;

cout<<endl;

system("PAUSE");

return 0;

}

22 //ALGORYTM OBLICZANIA WARTOSCI PRZYBLIZONEJ FUNKCJI EXP

//EXP=1 + X^1/1! + X^2/2!+...+X^i/i!

#include <iostream>

#include <stdlib.h>

using namespace std;

int x;

double z;

double res=1;

double eps=0.0001;

double ti=1;

int i=1;

double eksponenta(int x)

{

while(ti>=eps)

{

ti=ti*x/i;

res+=ti;

i++;

}

return x;

}

int main(int argc, char *argv[])

{

cout<<"PODAJ x dla jakiego chcesz obliczyc esponenta"<<endl;

cin>>x;

z=eksponenta(x) ;

cout<<"wynik wynosi e="<<res<<endl;

system("PAUSE");

return 0;

}

22//ALGORYTM OBLICZANIA WARTOSCI PRZYBLIZONEJ FUNKCJI SINX

//X-X^3/3!+X^5/5!-X^7/7!=(-1)^i-1 * X^(2i-1)/(2i-1)!

#include <iostream>

#include <stdlib.h>

#include <math.h>

#define PI 3.141592653589

using namespace std;

double eps=0.00001;

double res=0;

int i=1;

int x2;

double z;

double sinus (int x)

{

double y;

y=x*PI/180;

res=y;

double ti=y;

while(fabs(ti)>=eps)

{

ti=-ti* (y*y)/(2*i*(2*i+1));

res+=ti;

i++;

}

return y;

}

int main(int argc, char *argv[])

{

cout<<"podaj kat dla jakiego chcesz obliczyc sinx"<<endl;

cin>>x2;

z= sinus(x2) ;

cout<<"wartosc sin(x) wynosi " <<res<<endl;

system("PAUSE");

return 0;

}

22//ALGORYTM OBLICZANIA WARTOSCI PRZYBLIZONEJ FUNKCJI COSX

//1-X^2/2!+X^4/4!-X^6/6!=(-1)^i * X^(2i)/(2i)!

#include <iostream>

#include <stdlib.h>

#include <math.h>

#define PI 3.141592653589

using namespace std;

int main(int argc, char *argv[])

{

double eps=0.001;

double res=0;

int i=1;

double x;

cout<<"podaj kat dla jakiego chcesz obliczyc cosx"<<endl;

cin>>x;

x=x*PI/180;

res=1;

double ti=1;

while(fabs(ti)>=eps)

{

ti=-ti* (x*x)/( (2*i-1)*2*i );

res+=ti;

i++;

}

cout<<"wartosc cos(x) wynosi " <<res<<endl;

system("PAUSE");

return 0;

}

24 //ALGORYTM ZAMIANY LICZB DWOJKOWYCH NA DZIESIETNE

#include <iostream>

#include <stdlib.h>

using namespace std;

int main(int argc, char *argv[])

{

char c;

int res=0;

cout<<"podaj liczbe dwojkowa"<<endl;

while( ( ( c=getchar() )>='0' ) && (c<='1') )

{

res=res*2+(c-'0');

}

cout<<"liczba dziesietna to "<<res<<endl;

system("PAUSE");

return 0;

}

Z OKT NA DEC

using namespace std;

int main(int argc, char *argv[])

{

int res = 0; //wartosc liczby osemkowej

char c; //pojedynczy znak z liczby osemkowej

printf("Podaj liczbe w systemie osemkowym ");

while( (c = getchar()) >= '0' && (c <= '7'))

res = res*8 + (c - '0');

cout << "Wartosc dziesietna: " << res << '\n';

system("PAUSE");

return EXIT_SUCCESS;

}

25 //ALGORYTM ZAMIANY LICZB DZIESIETNYCH NA LICZBY W KODZIE UZUPELNIENIOWYM

#include <iostream>

#include <stdlib.h>

#define MAX 30

using namespace std;

//FUNKCJA LICZACA POTEGI

int pow(int a,int b)

{

int temp=1;

while(b)

{

temp*=a;

b--;

}

return temp;

}

int main(int argc, char *argv[])

{

int x;

int t[MAX]={0};

int i=0;

int bit;

int U2=0;

cout<<" podaj liczbe ktore chcesz zamienic na system dwojkowy "<<endl;

cin>>x;

while(x)

{

if(x%2==0)

{

t[i]=0;

bit=0;

}

else

{

t[i]=1;

bit=1;

}

U2=U2+bit*pow(2,i);

x/=2;

i++;

}

U2=U2-2*pow(2,(i-1));

cout<<endl;

//wypisanie liczby dwojkowej

for(i=i-1;i>=0;i--)

cout<<t[i];

cout<<endl;

cout<<U2;

cout<<endl;

system("PAUSE");

return 0;

}

26 PIERGWIATKI WIELOMIANU

#include <cstdlib>

#include <iostream>

#include <math.h>

using namespace std;

#define N 4

#define P 20

#define Q 20

double schemat(double x);

int wsp[N] = {1,-1,-9,9};

int main(int argc, char *argv[])

{

double p[P] = {0};

double q[Q] = {0};

int j = 0; //ilosc podzielnikow wyrazu wolnego

for(int i = 1; i <= abs(wsp[N-1]); i++)

{

if((wsp[N-1]%i) == 0)

{

p[j] = i;

j++;

}

int k = 0; //ilosc podzielnikow wsp przy najwyzszej potedze

for(int i = 1; i <= abs(wsp[0]); i++)

{

if((wsp[0]%i) == 0)

{

q[k] = i;

k++;

}

double t[j][k]; //tablica domniemanych pierwiastkow

for(int i = 0; i < j; i++)

{

for(int r = 0; r < k; r++)

t[i][r] = (double)(p[i]/q[r]);

}

for(int i = 0; i < j; i++)

{

for(int z = 0; z < k; z++)

cout << t[i][z] << ' ';

cout << endl;

}

cout << endl;

for(int i = 0; i < j; i++)

{

for(int z = 0; z < k; z++)

{

if(schemat(t[i][z]) == 0.0)

cout << t[i][z] << " jest pierwiastkiem" << endl;

if(schemat(-t[i][z]) == 0.0)

cout << (-t[i][z]) << " jest pierwiastkiem" << endl;

}

cout << endl;

system("PAUSE");

return EXIT_SUCCESS;

}

double schemat(double x)

{

double w = 0;

int i = 0;

for(i; i < N; i++)

w = w*x + wsp[i];

return w;

}

27 //ALGORYTM WCZYTUJACY ZNAKOWO LICZBE RZECZYWISTA I OBLICZAJACY JEJ WARTOSC

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

#include <cstdlib>

#include <iostream>

using namespace std;

int IsDigit (char c);

void SkipSpaces();

int GetNum ();

int main(int argc, char *argv[])

{

int res=0;

char c;

printf ("podaj liczbe osemkowa: ");

cout << "Wartosc liczby osemkowej: " << GetNum () << "\n";

system("PAUSE");

return EXIT_SUCCESS;

}

int IsDigit (char c)

{

return ((c>='1') && (c<='1'));

}

void SkipSpaces()

{

char c;

while ( (c=getchar())== ' ');

ungetc (c,stdin);

}

int GetNum ()

{

char c;

int res=0;

SkipSpaces();

while (IsDigit(c=getchar()))

res=res*2+(c-'0');

return res;

}

29 //ALGORYTM ZNAJDOWANIA W CIAGU a1...an PODCIAGU O MAKSYMALNEJ DŁUGOSCI

//ZAWIERAJACY JEDNAKOWE ELEMENTY alg liniowy

#include <iostream>

#include <stdlib.h>

#include <cstdlib>

#include <time.h>

#define MAX 12

using namespace std;

int main(int argc, char *argv[])

{

int t[MAX]={0};

int i=0;

int dlp=1;

int dlk=1;

int ink;

int inp;

srand((unsigned)time(NULL));

for(i=0;i<MAX;i++)

t[i]=rand()%MAX/3+1;

for(i=0;i<MAX;i++)

cout<<t[i]<<' ';

for(i=0;i<MAX-1;i++)

{

if(t[i]==t[i+1])

{

dlp++;

if(dlp>=dlk)

{

dlk=dlp;

ink=i+1;

}

else continue;

}

else

dlp=1;

}

inp=ink-dlk+1;

cout<<"max podciag tych samych elementow ma dlugosc "<<dlk<<endl;

cout<<"index poczatkowy tego podciagu to "<<inp<<" a koncowy "<<ink;

cout<<endl;

system("PAUSE");

return 0;

}

36 WIEŻA HANOI

#include <iostream>

#include <stdlib.h>

using namespace std;

void HANOI(int n,char A,char B,char C)

{

if(n>1)

{

HANOI(n-1,A,C,B);

HANOI(1,A,B,C) ;

HANOI(n-1,B,A,C);

}

else cout<<"przeniesc krazek z " <<A<<"----->"<<C<<endl;

}

int main(int argc, char *argv[])

{

int n;

cout<<"podaj ile krazkow chcesz przeniesc "<<endl;

cin>>n;

HANOI(n,'A','B','C');

system("PAUSE");

return 0;

}

// WIEZA HANOI GRA ALGORYTM NA INTACH ( REKURENCYJNY !!! )

#include <iostream>

#include <stdlib.h>

using namespace std;

int n;

void HANOI(int n,int A,int B, int C)

{

if(n>1)

{

HANOI(n-1,A,C,B);

HANOI(1,A,B,C);

HANOI(n-1,B,A,C);

}

else cout<<"przenisc krazek z "<<A<<"----> "<<C<<endl ;

}

int main(int argc, char *argv[])

{

cout<<"podaj ile krazkow chcesz przeniesc "<<endl;

cin>>n;

HANOI(n,1,2,3);

system("PAUSE");

return 0;

}

19 MNOŻENIE MACIERZY

#include <cstdlib>

#include <iostream>

#include <time.h>

#include <stdlib.h>

#define AW 3

#define AK 4

#define BW 4

#define BK 2

using namespace std;

int main(int argc, char *argv[])

{

int a[AW][AK] = {0};

int b[BW][BK] = {0};

srand((unsigned)time(NULL));

for(int i = 0; i < AW; i++)

{

for(int j = 0; j < AK; j++)

a[i][j] = rand()%((AW*AK)/2) + 1;

}

for(int i = 0; i < BW; i++)

{

for(int j = 0; j < BK; j++)

b[i][j] = rand()%((BW*BK)/2) + 1;

}

cout << "MACIERZ A: " << endl;

for(int ii = 0; ii < AW; ii++)

{

for(int jj = 0; jj < AK; jj++)

cout << a[ii][jj] << ' ';

cout << endl;

}

cout << endl;

cout << "MACIERZ B: " << endl;

for (int i = 0; i < BW; i++)

{

for(int j = 0; j < BK; j++)

cout << b[i][j] << ' ';

cout << endl;

}

cout << endl;

int res = 0;

if(AK == BW)

{

int c[AW][BK] = {0};

for(int i = 0; i < AW; i++)

{

for(int j = 0; j < BK; j++)

{

res = 0;

for(int k = 0; k < BW; k++)

res += a[i][k] * b[k][j];

c[i][j] = res;

}

cout << "MACIERZ C: " << endl;

for (int i = 0; i < AW; i++)

{

for(int j = 0; j < BK; j++)

cout << c[i][j] << ' ';

cout << endl;

}

cout << endl;

}

else cout << "Nie mozna mnozyc macierzy o tych wymiarach!" << endl;

system("PAUSE");

return EXIT_SUCCESS;

}

Wyszukiwarka

Podobne podstrony:
Układy Napędowe oraz algorytmy sterowania w bioprotezach
5 Algorytmy
5 Algorytmy wyznaczania dyskretnej transformaty Fouriera (CPS)
Tętniak aorty brzusznej algorytm
Algorytmy rastrowe
Algorytmy genetyczne
Teorie algorytmow genetycznych prezentacja
Algorytmy tekstowe
Algorytmy i struktury danych Wykład 1 Reprezentacja informacji w komputerze
ALGORYTM EUKLIDESA
Algorytmy z przykladami tp 7 0

więcej podobnych podstron