#include <stdio.h>

/** 
	Integer tomb kiiratasa
*/
void kiirIntegerTomb(int tomb[], int meret){
	int i;
	for (i=0; i<meret; i++){
		printf("%4d", tomb[i]);	
	}
	printf("\n");
}


/** 
	Char tomb kiiratasa
*/
void kiirCharTomb(char tomb[]){
	int i = 0;
	while (tomb[i] != 0){
		printf("%c", tomb[i]);
		i++;	// INDEXVALTOZO NOVELESE, HOGY NE LEGYEN VEGTELEN CIKLUS
	}
	printf("\n");
}


/** 
	(a) Írjunk egy ciklust, amely végig ellenorzi egy bemenetként kapott n szám esetén, hogy 1-tol 1000-ig mely számok oszthatóak n^2+n+1-gyel
*/
int fgvA(int n){
	int i;
	for (i=1;i<1000;i++){	// vegig iteralunk 1-tol 1000-ig
		if (i%(n*n+n+1) == 0) {	// mindig az aktualis elemet elosszuk a megadott kifejezessel es vesszuk a maradekot
								// amennyiben a maradek 0, akkor oszthatoak
			printf("%4d\n", i);
		}
	}
	return 0;	// mivel nem volt megadva, hogy mi legyen a visszateresi ertek, ezert 0-t adunk vissza
}


/** 
	(b) Keressük meg egy tömb legnagyobb/legkisebb elemét. Ez az elem legyen a fuggveny visszateresi erteke.
	(Itt most epp legkisebb. Legnagyobb eseten csak meg kellene forditani a relacios jelet az if soraban.)
*/
int fgvB(int tomb[], int meret){
	int min, i;
	min = tomb[0];	// kimentjuk a tomb elso (0.) elemet
	for (i=1;i<meret;i++){	// vegig iteralunk rajta (A 0. elemet mar kivettuk, szoval az 1.-tol megyunk tovabb, egeszen a vegeig)
		if (tomb[i] < min){	// amennyiben a tomb i-edik (azaz az aktualis) eleme kisebb, mint a min erteke
			min = tomb[i];	// akkor felulirjuk a min-t vele
		}
	}
	return min;	// a legkisebb elem a visszateresi ertek
}


/**
	(c) Írjunk egy függvényt, melynek legyen 4 egész értéku bemeneti paramétere. 
	Az 1. legyen egy 1D int tömb. A 2. a tömb mérete. A 3. és a 4. egy-egy adott egész érték. 
	A 3. parameterkent megadott erteku tomb elemet irjuk felul a 4. parameterkent megadott ertekkel.
*/
void fgvC(int tomb[], int meret, int a, int b){
	int i;	// index valtozo
	kiirIntegerTomb(tomb, meret);	// tomb aktualis allapotanak kiiratasa
	for (i=0; i<meret; i++){	// vegig iteralunk a tombunkon (0. elemtol a legutolsoig)
		if (tomb[i] == a){	// ha a tomb i-edik (azaz az aktualis) eleme egyenlo a 3. parameter ertekevel
			tomb[i] = b;	// akkor kicsereljuk a 4. perameter ertekere
		}
	}
	kiirIntegerTomb(tomb, meret);	// tomb aktualis allapotnak kiiratasa, hogy lassuk a valtozasokat
}


/**
	(d) A (c) feladat módosítása úgy, hogy a 3. paraméterben megadott indexszu elemet cseréljük ki, a 4. paraméterben megadott indexszu elemmel.
		Tehát a 3. elemet a 4.-re, a 4.-et pedig a 3.-ra.
*/
void fgvD(int tomb[], int meret, int a, int b){
	int i, tmp;	// indexvaltozo es segedvaltozo a cserehez
	kiirIntegerTomb(tomb, meret);	
	for (i=0; i<meret; i++){
		if (i == a){	// ha az index megegyezik a 3. parameter ertekevel, akkor 3 lepeses ("haromszog") csere
			tmp = tomb[a];		// kimentjuk az egyik elemet
			tomb[a] = tomb[b];	// ekkor mar felul irhatjuk
			tomb[b] = tmp;		// a tmp-be mentett ertek mehet a masik valtozoba 
		}
	}
	kiirIntegerTomb(tomb, meret);
}


/**
	(e) Hozzunk létre egy integer 2D tömböt és töltsük fel a szorzótábla értékeivel.
*/
int fgvE(int tomb[][10]) {	// egy 2D tomb parameterkent valo megadasakor meg kell adni a meretet is legalabb a masodik tomb zarojelben
	int i,j;	// index valtozok

	for (i=0;i<10;i++){	// az i fogja jelolni, hogy hanyadik sorban jarunk
		for (j=0;j<10;j++){	// a j fogja jelolni, hogy hanyadik oszlopban jarunk
			tomb[i][j]=(i+1)*(j+1);	// a tomb [i][j]-edik (azaz az aktualis) elemet felul irjuk. 
									// i*j lenne normal korulmenyek kozott, viszont mivel 0-tol indul az indexszeles, 
									// ezert az i es a j erteket is szorzas elott megnoveljuk 1-gyel, hogy ne 0*0-val, 
									// hanem 1*1-gyel kezdjuk a tablat.
			printf("%4d", tomb[i][j]);	// kiiratas
		}
		printf("\n");	// ujsor irasa minden egyes sornak a feldolgozasa utan. Ez csak a tablazatos megjelenites miatt kell.
						// a tomb feldolgozasan es feltoltesen nem valtoztat
	}
	return 0;	// mivel nem volt megadva, hogy mi legyen a visszateresi ertek, ezert 0-t adunk vissza
}


/**
	(f) Ellenorizzuk le egy karaktertomb hosszat. Toljuk el az osszes karaktert 1-gyel. A fuggveny a tomb meretevel terjen vissza.
*/
int fgvF(char tomb[]){
	int i = 0, meret = 0;	// indexvaltozo es a meret tarolasara hasznalt valtozo letrehozasa. Nagyon fontos a 0 kezdoertek!!
	while (tomb[i] != 0){	// egesz addig haladunk vegig a tombon, amig meg nem latjuk a 0 jelet, ami a veget jelzi.
		meret++;			// noveljuk a meret valtozot, amig nem latjuk a 0 jelet
		i++;	// INDEXVALTOZO NOVELESE, HOGY NE LEGYEN VEGTELEN CIKLUS
	}
	kiirCharTomb(tomb);
	for (i=0;i<meret;i++){	// vegig iteralunk a tombon. Most felhasznaljuk a meret valtozot, de itt is megtehetnenk, hogy 0 jelig megyunk
		tomb[i] = tomb[i] + 1;			// minden karakterhez adjunk hozza 1-et.
	}
	kiirCharTomb(tomb);
	
	return meret;	// visszateresi ertek
}



int main(){

	int t1[10] = {5,3,12,7,4,89,1,8,9,45}, // 1D int tomb
		t2[10][10], // 2D int tomb
		m = 10;	// meret valtozo
	char t3[8] = {'b','e','l','a','f','u','t', 0};	// 1D char tomb
	
	/** Pelda a fuggvenyek hivasara */
	
//	fgvA(20);

//	printf("%d\n",fgvB(t1,m));

//	fgvC(t1,m,3,100);

//	fgvD(t1,m,2,5);	
	
//	fgvE(t2);

//	fgvF(t3);

	return 0;
}