Programozási alapismeretek 2. | Csonka Péter

https://docs.google.com/document/d/16CnfKOQI8-2_831HP18KG52ETqqdPmhy3sIzq2vNZXE/edit

Hanoi torony:

```
#include <iostream>
```
```
 
```
```
using namespace std;
```
```
 
```

double hatvany(const double a, const int n){

```
	if(n==0){
```
```
    	return 1;
```
```
	} else {
```
```
    	return a*hatvany(a,n-1);
```
```
	}
```
```
}
```
```
 
```
```
//int i=0;
```
```
 
```
```
int fib(const int n){
```
```
//	i++;
```
```
	if(n==0){
```
```
    	return 0;
```
```
	} else if(n==1){
```
```
    	return 1;
```
```
	} else {
```
```
    	return fib(n-1)+fib(n-2);
```
```
	}
```
```
 
```
```
}
```
```
 
```

void hanoi(const int h, char honnan, char hova, char mivel){

```
	if(n>0){
```
```
    	hanoi(n-1, )
```
```
	}
```
```
}
```
```
 
```
```
int main(){
```
```
//	cout << hatvany(2,3) << endl;
```
```
//	cout << fib(10) << endl;
```
```
//	cout << "lepesek: " << i << endl;
```

	hanoi(3,'A','C','B'); // A-ról C-re rakjuk B segítségével

```
	return 0;
```
```
}
```

Stuct:

```
#include <iostream>
```
```
#include <vector>
```
```
 
```
```
using namespace std;
```
```
 
```
```
struct Eredmeny{
```
```
	bool van;
```
```
	int hol;
```
```
}
```
```
 
```

Eredmeny fel11(const vector<double> hom, const int n){

```
	Eredmeny sv;
```
```
	if(n==-1){
```
```
    	// fel11:=(hamis,?) a feladatban
```
```
    	sv.van = false;
```
```
    	return sv;
```
```
	} else if(hom[n]<-10){
```
```
    	// fel11:=(igaz,n)
```
```
    	sv.van = true;
```
```
    	sv.hol = n;
```
```
    	return sv;
```
```
	} else {
```
```
    	return fel11(hom, n-1);
```
```
	}
```
```
}
```
```
 
```
```
int main()
```
```
{
```
```
	vector<double> hom;
```
```
	Eredmeny er;
```
```
 
```
```
//	beolvasas(hom); // othonra
```
```
	hom.push_back(1);
```
```
	hom.push_back(-11);
```
```
	hom.push_back(5);
```
```
 
```
```
	er = fel11(hom, hom.size()-1);
```
```
	cout << er.van << er.hol << endl;
```
```
 
```
```
	return 0;
```
```
}
```

Tovább olvasás →

https://docs.google.com/document/d/1B-kSmTuQu89YU8XOb72IlyRp3PL1NpzvBGdLt4UxfcE/edit

```
#include <iostream>
```
```
#include <vector>
```
```
#include <cstdlib>
```
```
 
```
```
using namespace std;
```
```
 
```

void beolvasas(vector< vector<int> > &jegyek);

int beolvas_egesz(const string uzenet, const string hibauzenet);

int beolvas_jegy(const int i, const int j);

bool fel11a(const vector< vector<int> > jegyek);

bool csupaotos(const int i, const vector< vector<int> > jegyek);

```
 
```
```
int main(){
```

	vector< vector<int> > jegyek; // a két záró kacsacsõr közé mindenképp kell a szóköz

```
	bool van;
```
```
 
```
```
	beolvasas(jegyek);
```
```
	van = fel11a(jegyek);
```
```
	if (van){
```
```
    	cout << "Van" << endl;
```
```
	} else {
```
```
    	cout << "Nincs" << endl;
```
```
	}
```
```
 
```
```
	return 0;
```
```
}
```

bool fel11a(const vector< vector<int> > jegyek){

```
	int i=0;
```
```
	int n=jegyek.size();
```

	while(i<=(n-1) && !csupaotos(i, jegyek)){

```
    	i++;
```
```
	}
```
```
	return i<=n-1;
```
```
}
```

bool csupaotos(const int i, const vector< vector<int> > jegyek){

```
	int j=0;
```
```
	int m=jegyek[i].size();
```

	while((j<=(m-1)) && (jegyek[i][j]==5)){

```
    	j++;
```
```
	}
```
```
	return j>(m-1);
```
```
}
```
```
 
```

void beolvasas(vector< vector<int> > &jegyek){

```
	int n, m;
```
```
 
```

	n = beolvas_egesz("Hany diak: ", "Nem negativ kell!");

	m = beolvas_egesz("Hany targy: ", "Nem negativ kell!");

```
 
```
```
	jegyek.resize(n);
```
```
	for(int i=0; i<n; i++){
```
```
    	jegyek[i].resize(m);
```
```
    	for(int j=0; j<m; j++){
```

        	jegyek[i][j] = beolvas_jegy(i,j);

```
    	}
```
```
	}
```
```
}
```

int beolvas_egesz(const string uzenet, const string hibauzenet){

```
	int n;
```
```
	bool hiba;
```
```
 
```
```
	do{
```
```
    	cout << uzenet;
```
```
    	string str;
```
```
    	cin >> str;
```

    	n = atoi(str.c_str()); // atof float-hoz

```
    	hiba = n==0 && str!="0" || n<0;
```
```
    	if(hiba){
```
```
        	cout << hibauzenet << endl;
```
```
    	}
```
```
	} while(hiba);
```
```
 
```
```
	return n;
```
```
}
```

int beolvas_jegy(const int i, const int j){

```
	int n;
```
```
	bool hiba;
```
```
 
```
```
	do{
```

    	cout << i+1 << ". diak " << j+1 << ". jegye: ";

```
    	string str;
```
```
    	cin >> str;
```

    	n = atoi(str.c_str()); // atof float-hoz

    	hiba = n==0 && str!="0" || n<1 || n>5;

```
    	if(hiba){
```

        	cout << "1 es 5 kozott kell lennie!" << endl;

```
    	}
```
```
	} while(hiba);
```
```
 
```
```
	return n;
```
```
}
```

Tovább olvasás →

https://docs.google.com/document/d/1H8-kF2jE0MuSrao__M93YroymuTdUKxdNlAeak5MHOk/edit

```
#include <iostream>
```
```
#include <fstream>
```
```
#include <vector>
```
```
 
```
```
using namespace std;
```
```
 
```
```
void beolvasas(vector<double> &x);
```
```
void beolvasas_file(vector<double> &x);
```

void fel1(const vector<double> hom, double &atlag);

void fel3(const vector<double> hom, int &leghidegebbnap);

void fel7(const vector<double> hom, bool &van, int &ind);

void ellkiiras(const vector<double> &hom);

```
 
```
```
int main()
```
```
{
```
```
    //double hom[MAXN];
```
```
    vector<double> hom;
```
```
 
```
```
    //beolvasas(hom);
```
```
    beolvasas_file(hom);
```
```
    ellkiiras(hom);
```
```
 
```
```
    double atlag;
```
```
    fel1(hom, atlag);
```

    cout << "Atlaghom= " << atlag << endl;

```
 
```
```
    int leghidegebbnap;
```
```
    fel3(hom, leghidegebbnap);
```

    cout << "Leghidegebbnap= " << leghidegebbnap << endl;

```
 
```
```
    bool van;
```
```
    int ind;
```
```
    fel7(hom, van, ind);
```
```
    if (van)
```
```
    {
```

        cout << "= a szomszedjaval: " << ind << endl;

```
    }
```
```
    else
```
```
    {
```

        cout << "Nincs = a szomszedjaval" << endl;

```
    }
```
```
 
```
```
    return 0;
```
```
}
```
```
 
```
```
void beolvasas(vector<double> &x)
```
```
{
```
```
    int n;
```
```
    cout << "n=";
```
```
    cin >> n;
```
```
    x.resize(n);
```
```
    for (int i=0; i<n; ++i)
```
```
    {
```
```
        cout << i << ". hom: ";
```
```
        cin >> x[i];
```
```
    }
```
```
}
```
```
 
```
```
void beolvasas_file(vector<double> &x)
```
```
{
```
```
    double sv;
```
```
    //ifstream f("be.txt");
```
```
    ifstream f;
```
```
    string fajlnev;
```
```
    bool hiba;
```
```
 
```
```
    do
```
```
    {
```
```
        cout << "Fajlnev: ";
```
```
        cin >> fajlnev;
```
```
        f.open(fajlnev.c_str());
```
```
        hiba=f.fail();
```
```
        if (hiba)
```
```
        {
```

            cout << "Nem jo fajlnev" << endl;

```
        }
```
```
    }
```
```
    while(hiba);
```
```
 
```
```
    /*while (!f.eof())
```
```
    {
```
```
        f >> sv;
```
```
        if (f.good())
```
```
        {
```
```
            x.push_back(sv);
```
```
        }
```
```
    }*/
```
```
 
```
```
    f >> sv;
```
```
    while (!f.eof())
```
```
    {
```
```
        x.push_back(sv);
```
```
        f >> sv;
```
```
    }
```
```
 
```
```
    f.close();
```
```
}
```
```
 
```

void ellkiiras(const vector<double> &hom)

```
{
```
```
    for (int i=0; i<hom.size(); ++i)
```
```
    {
```

        cout << i << ".: " << hom[i] << endl;

```
    }
```
```
}
```
```
 
```

void fel1(const vector<double> hom, double &atlag)

```
{
```
```
    double s=0;
```
```
    int n=hom.size();
```
```
    for (int i=0; i<n; ++i)
```
```
    {
```
```
        s+=hom[i];
```
```
    }
```
```
    atlag=s/n;
```
```
}
```
```
 
```

void fel3(const vector<double> hom, int &leghidegebbnap)

```
{
```
```
    double max=hom[0];
```
```
    leghidegebbnap=0;
```
```
    for (int i=0; i<hom.size(); ++i)
```
```
    {
```
```
        if (hom[i]<max)
```
```
        {
```
```
            leghidegebbnap=i;
```
```
            max=hom[i];
```
```
        }
```
```
    }
```
```
}
```
```
 
```

void fel7(const vector<double> hom, bool &van, int &ind)

```
{
```
```
    ind=0;
```

    while (ind<hom.size() && hom[ind]!=hom[ind+1])

```
    {
```
```
        ++ind;
```
```
    }
```
```
    van=ind<hom.size();
```
```
}
```

Tovább olvasás →

Az előadásra nem sikerült bemennem, de az 1. hét gyakorlatai megvoltak. Szerintem egész jóra sikerült ez a tárgy átalakítás. A Dokumentum erre található, a 4. oldalon lévő feladat kódja pedig a tovább mögött.

Mod #1: Előkerítettem a régi Programozási Tételek .pdf-emet, úgyfest szükség lesz rá.
(tovább…)

Tovább olvasás →

ELTE > Web-Programozó > 2. félév > Programozási alapismeretek 2.

Programozási alapismeretek 2. - 4. hét

Programozási alapismeretek 2. - 3. hét

Programozási alapismeretek 2. - 2. hét

Programozási alapismeretek 2. - Mondatszerű leírás

Tantárgyak