// fejállományok: <> rendszer, "" saját
// #include "sajat.h"
#include <stdio.h>	// printf(), sizeof()


// definició, előfordításkor behelyettesítődik
// nem szabad ; lezárni
#define PI 3.14159

// Szinonim típusnév
typedef unsigned char byte;

// globális változók helye

// főprogram
int main(void)					// a program belépési pontja
{
	printf("Hello MOGI :)\n");	// kiíratás a konzolra, \n új sor
	
	//lokális változók
	int a;						// egész változó
	const int b = -20;			// konstans, kötelező értéket adni
	unsigned int egesz, Egesz;	// kis/nagy betűk megkülönböztetve

	egesz = 20;		// 20 - decimális
	Egesz = 0xA;	// 10 - hexadecimális
	Egesz = 0111;	// 73 - oktális
	Egesz = 0b111;	// 7 - bináris

	Egesz = b;	// értékadás (signed -> unsigned) ?

	//b = 2;   // b csak olvasható

	a = 30;

	printf("a erteke: %d \n", a);				// %d vagy %i egész
	printf("a erteke oktalisan: 0%o \n", a);		// %o oktális
	printf("a erteke hexadecimalisan: 0x%x \n", a);	// %x vagy %X hexa
	printf("a merete a memoriaban: %i byte\n", sizeof(a));	//sizeof változó vagy típus mérete
	printf("short int merete a memoriaban: %i byte\n", sizeof(short int));
	printf("long long merete a memoriaban: %i byte\n", sizeof(long long));	// szám LL

	printf("a = %d, b = %d\n", a, b);			// annyi változó, ahány a formátumban szerepel

	double tort = 3.14;		// tizedestört mindig .

	printf("tort erteke: %f\n", tort);		// float
	printf("tort erteke: %5.1f\n", tort);	// 1 tizedes, 5 összes
	printf("tort erteke: %.1f\n", tort);	// 1.tizedes
	printf("tort erteke: %e\n", tort);		// normál alak %e vagy %E
	printf("tort erteke: %g\n", tort);		// amelyik rövidebb: %e vagy %f
	printf("double merete: %d byte\n", sizeof(tort));

	float pi = 3.14159f;	// float szám után f!

	printf("a pi erteke: %.4f\n", pi);
	printf("a pi erteke: %.4f\n", PI);		// PI definició behelyettesítődik
	printf("float merete: %d byte\n", sizeof(float));

	char c = 67;			// ASCII karakter 'C'

	printf("c erteke: %d \n", c);
	printf("c ASCII karaktere: %c \n", c);
	printf("char merete: %d byte\n", sizeof(char));

	byte adat = 256;	//0..255

	return 0;
}

// Matematikai konstansok definicióinak használata <math.h> elött
// pl.: M_PI
#define _USE_MATH_DEFINES

#include <stdio.h>	// printf, scanf(_s)
#include <math.h>	// matematikai készlet

#define PI 3.14159
#define DUPLA(x) x*2

typedef unsigned char byte;

//globális változók
int egesz;
double tort = PI;
const unsigned int konstans = 3;

int main(void)
{
	//globális változó akkor is használható, ha nincs kezdeti értéke
	printf("egesz erteke: %i", egesz);

	//lokális változók (printf elött értéket kell adni neki)
	int i = 10;		// értékadás
	double d = i;	// implicit típus-átalakítás (kicsi -> nagy)
	float f = (float)d;	// explicit típus-átalakítások
	f = (float)42.56; // vagy 42.56f
	i = (int)f;		// adatvesztés, eltűnik a törtrész

	// változók hatóköre
	{
		int i = 5;
		int z = 10;	// z változó a hatókörön kívül nem lesz használható
		printf("belso i erteke: %i z = %i\n", i, z);
	}
	//itt már nincs z változó, és i is a külsõ változó lesz
	printf("kulso i erteke: %i\n", i);

	// bal érték, jobb érték fogalma
	tort = (double)1 / 2;	//vagy  1 / 2.0

	// műveletek sorrendisége + típusok
	tort = (5 + 3 * 2 - 6) / ((double)3 / 2) * 5;

	int a = 10;
	int b;
	a = a + 1;  //a=11;
	// összevont alak +=, -= , *=, /=
	a += 2;		//a=13;

	// egy operandusú műveletek
	a++;		//a=14;
	b = a++;	//b=14 a=15
	b = ++a;	//b=16 a=16

	int db = 21 / 5;			// egész osztás
	int maradek = 21 % 5;		// maradék

	// matematikai műveletek <math.h>
	// sin - szinus radiánban!
	// cos - koszinusz radiánban
	// pow - hatványozás pow(alap, kitevõ)
	// sqrt - gyökvonás
	// exp - e^x
	// log - természetes alapú logaritmus
	// log10 - 10-es alapú logaritmus
	double szamolas = pow(sin(M_PI / 3), (double)2 / 3);	//(sin(PI/3))^(2/3)	

	byte szam = 257;	// 0-255
	szam = 10;
	szam = ~szam;

	b = 0b00000110; //6;
	szam = 10;
	szam |= 1 << 2; //2. bit bebillentése
	szam &= ~(1 << 3); // 3. bit törlése

	return 0;
}

#include <stdio.h>
#include <math.h>	// matematikai készlet

int main(void)
{

	int szam_egesz;
	printf("Adjon meg egy egesz szamot: ");
	// érték beolvasása a változóba (címet & kell megadni)
	scanf("%i", &szam_egesz);		// Microsoft biztonságos verzió scanf_s
	printf("A megadott szam: %i\n", szam_egesz);

	double szam_tort;
	printf("Adjon meg egy tort szamot: ");
	scanf("%lf", &szam_tort);			// double/float esetén %lf kell
	printf("A megadott szam: %lf\n", szam_tort);	// itt elgendõ a %f is

	// HF próbálja ki, hogy az egész szám helyébe írjon be 12.345-t
	// mi történt ? mi lehet ennek az oka?

	int ora, perc;
	printf("Kerem adja meg a pontos idot ora:perc alakban: ");
	// több elem beolvasása
	scanf("%i:%i", &ora, &perc);
	printf("A pontos ido: %i:%i\n", ora, perc);

	int szam = 14;

	//osztható-e 7-el?
	if (szam % 7 == 0) printf("Oszthato\n");
	else printf("Nem oszthato\n");

	if ((szam % 7 == 0) && (szam % 3 == 0))
	{
		printf("A szam oszthato\n");
	}
	else
	{
		printf("A szam nem oszthato\n");
	}

	szam = 10;
	if (szam) printf("igaz\n");
	if (!szam) printf("hamis?\n");

	double pontszam = 56;
	if (pontszam < 40) printf("Elegtelen\n");
	else if (pontszam < 55) printf("Elegseges\n");
	else if (pontszam < 70) printf("Kozepes\n");
	else if (pontszam < 85) printf("Jo\n");
	else printf("Jeles\n");

	int a = 20, b = 30, c;
	c = (a > b) ? a : b;	//melyik a nagyobb
	printf("c = %d\n", c);

	int jegy = 3;
	switch (jegy)
	{
	case 1:
		printf("Elegtelen\n");
		break;
	case 2:
		printf("Elegseges\n");
		break;
	case 3:
		printf("Kozepes\n");
		break;
	case 4:
		printf("Jo\n");
		break;
	case 5:
		printf("Jeles\n");
		break;
	default:
		printf("Erevenytelen jegy\n");
		break;
	case 0:
		printf("Nem teljesitve\n");
		break;
	}
	jegy > 1 ? printf(", Gratulalunk!") : printf(", Majd legkozelebb..");

	/*
	Gyakorlo feladat
	- x változó bekérése
	- megfelelő tartomány meghatározása
	- számítás elvégzése
	- eredmény kiíratása
	*/
	double x, eredmeny;
	printf("Feladat:\nx="); scanf_s("%lf", &x);
	if (x  < -1) eredmeny= cos(x);
	else if (x >= 1) eredmeny = sqrt(x);
	else eredmeny = pow(sin(x), 3);
	printf("A feladat megoldasa:\neredmeny=%6.3lf\n", eredmeny);

	return 0;
}		
		
		

		

#include <stdio.h>
#include <time.h>
#include <math.h>
#include <stdlib.h>		//rand, RAND_MAX

int main(void)
{
	//time_t ido;
	//ido = time(NULL); // 1970. jan 1-től eltelt sec
	//printf("%li\n", ido);
	//srand(ido);  // véletlenszám generálása az idővel
	
	// véletlenszám generálása az idővel
	srand((unsigned int)time(NULL));  // egy lépésben

	int szam = rand();

	printf("%i\n", szam);

	int szam2 = rand();

	printf("%i\n", szam2);

	printf("rand tartomanya 0-%i\n", RAND_MAX);

	szam = rand() % 100;  // 0..99

	szam = rand() % 101;  // 0..100

	printf("%i\n", szam);

	szam = (rand() % 101) - 50;    // -50..50

	// -20..20 2 lépésenként
	szam = 2*((rand()%21)-10);
	printf("%i\n", szam);

	double tort = (double)rand() / RAND_MAX ; // 0..1 közötti tört
	printf("%f\n", tort);

	tort = 10* ((double)rand() / RAND_MAX); // 0..10 közötti tört
	printf("%f\n", tort);

	// [0..10] 0.5 lépésközzel
	tort = (double)(rand() % 21) / 2;
	printf("%f\n", tort);

	// A tippek szamlalasahoz szukseges valtozok
	const int MAXTIPP = 10;			// próbálkozások maximális száma
	int tipp, tippszam = 0;

	// A kisorsolt szám: 1 - 100
	szam = rand() % 100 + 1;	// rand() tartománya 0 - RAND_MAX(32767)

	// Játék indul
	do // hátul tesztelt ciklus, 1x biztosan lefut!
	{
		printf("Kerem a tippet: ");
		scanf_s("%d", &tipp);

		tippszam++;

		if (tipp > szam)
			printf("Tul nagy a tipp!\n");
		else if (tipp < szam)
			printf("Tul kicsi a tipp!\n");

	} while (szam != tipp && MAXTIPP>tippszam);	// ; kell
	
	// Értékelés
	if (szam == tipp)
		printf("Gratulalok, kitalaltad %d lepesben\n", tippszam);
	else
		printf("Sajnos nem sikerult kitalalni, hogy mire gondoltam...\n");


	// Intervallum felezés módszere
	// sin(x) gyökének keresése x1, x2 között
	double x1 = 1;	// kezdet
	double x2 = 4;	// vég
	double xk = (x1 + x2) / 2;	// közép 
	double eps = 1E-12;			// hiba nagysága
	int lepes = 0;

	while (fabs(sin(xk)) > eps && lepes < 1e5)	// elöl tesztelt ciklus
	{
		if (sin(xk)*sin(x1) > 0) x1 = xk;
		else x2 = xk;
		xk = (x1 + x2) / 2;
		lepes++;
		printf("%d. fg(%3.14lf)=%.12lf\n", lepes, xk, sin(xk)); // 3,14159265358979
	} 


	// Karakter bekérése ciklussal
	// continue, break, return utasítások
	char c;
	do  
	{
		printf("Haza szeretnel menni? [i/n]");
		//scanf_s("%c", &c);			// több karakter + Enter ütés
		c = _getch();				// csak 1 karakter
		if (c == 'c') continue;		// c esetén újrakezdõdik a ciklus
		printf("%c\n", c);
		if (c == 'I') break;		// kilépés a ciklusból
		if (c == 'x') return -223;	// kilépés a fõprogramból
	} while (c != 'i' && c != 'n' );		// while(1) végtelen ciklus 

	if (c == 'i') printf("Ilyen koran?");

	return 0;
}
		

		

#include <stdio.h>	// printf, scanf(_s)
#include <conio.h>	// getch()
#include <math.h>	    // matematikai készlet
#include <stdlib.h>   // malloc

#define TMERET 10

int main(void)
{
	// Mutató használata
	int i = 100, j;  // lokális statikus változó stack-en
	int* p = NULL;   // pointer 
	p = &i;          // változó címét tárolja
	printf("i=%i &i=%i *p=%i p=%i &p=%p\n", i, &i, *p, p, p);

	i++;            // ha változik a statikus változó
	printf("i=%i *p=%i\n", i, *p);

	*p = 20;        // ha értéket adunk a pointer áltat mutatott változónak
	printf("i=%i *p=%i\n", i, *p);

	// precedencia szabály!!!
	*p++;           // (*p)++ *p+1 *(p+1) melyik mit csinál?
	printf("i=%i *p=%i\n", i, *p);

	// dinamikus terület foglalás heap-re
	double* pd = (double*)malloc(sizeof(double));
	*pd = 43.25;
	printf("%f\n", *pd);
	free(pd);
	// felszabadítás után már nem szabad használni!!
	printf("%f\n", *pd);
	
	// típus nélküli általános pointer
	void* pv = malloc(sizeof(double));
	printf("%x\n", pv);
	*(double*)pv = 43.25;
	printf("%lf\n", *(double*)pv);
	free(pv);
	pv = NULL;

	// Tömb és for ciklus
	int ti[TMERET]; //statikus tömb fix méretű lehet csak
	for (i = 0; i < TMERET; i++)
		ti[i] = i * i;

	for (i = 0; i < TMERET;)
		printf("%d ", ti[i++]);		
	printf("\n");

	// inicializálás
	int ti2[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };   // 10 elemű tömb - statikus
	const int tmeret = sizeof(ti2) / sizeof(ti2[0]); // megadja a tömb méretét  //sizeof(ti2)/sizeof(int)
	
	for (i = 0; i < tmeret; i++)
	    printf("%i ", ti2[i]);  //előre
	printf("\n");

	for (i = tmeret - 1; i >= 0; i--)
	    printf("%d ", ti2[i]); //vissza felé
	printf("\n");

	p = ti2;    // végigjárás pointerrel - pointer a tömb elejére irányítva
	for (i = 0; i < tmeret; i++)
	    printf("%i ", *(p++));  // *p++ is elég

	p = &ti2[tmeret - 1];  // visszafelé - pointer a tömb végére irányítva
	for (i = 0; i < tmeret; i++)
		printf("%d ", *(p--));
	printf("\n");

	// dinamikus tömbkezelés
	int* pi = (int*)malloc(tmeret * sizeof(int)); //10 elemű tömb - dinamikus
	for (i = 0, j = tmeret - 1; i < tmeret; i++, j--)
		pi[i] = ti[j]; // pi[i] = *(ti+i)

	for (i = 0; i < tmeret; i++)
		printf("%i ", *(pi + i));
	printf("\n");

	free(pi);    // felszabadítás, pi-t nem szabad elmozdítani

	return 0;
}		
		
		

#include <stdio.h>   // printf, scanf(_s)
#include <stdlib.h>  // RANAD_MAX, malloc
#include <time.h>	   // time

#define TMERET 10

//Struktúra
struct p2D {
	double x;
	double y;
	//int index;  //további adatok
};

//Állnév
typedef unsigned int byte;

//Stuktúra állnévvel
typedef struct {
	int x, y;
} pixel_t;

int main(void)
{
	int i;
	srand((unsigned int)time(NULL));

	// statikus tömb
	double st[TMERET];
	double * pp = st;		// végigjárás pointerrel
	for (i = 0; i<TMERET; i++)
		*(pp++) = (double)(rand() % 201) / 2 ;		//st[i]
	// a program végéig megmarad!!!!;
	printf("statikus tomb: %x\n", st);

	// dinamikus tömb
	int meret = 1000;
	double * dt = (double *)malloc(meret * sizeof(double));
	printf("dinamikus tomb: %x\n", dt);
	for (i = 0; i<meret; i++)
		dt[i] = (double)rand() / RAND_MAX * 1000;
	// nem marad meg!!!!;
	free(dt);

	// Összegzés
	double osszeg = 0;
	for (i = 0; i < TMERET; i++)
		osszeg += st[i];
	printf("Az osszeg: %lf\n", osszeg);

	// Megszámolás
	int db = 0;
	for (i = 0; i < TMERET; i++)
		if (st[i] < 50) db++;
	printf("A 50-nel kisebb szamok: %d\n", db);

	// HF: tömb elemének megkeresése -> van / nincs
	//     tömb elemének megkeresése -> hely indexe / -1 ha nincs
	//     tömb elemeinek átlaga
	//     tömb legnagobb eleme
	//     tömb legkisebb eleme

	// Buborék rendezés
	int j;
	double tmp;
	for (i = TMERET - 1; i>0; i--){
		for (j = 0; j<i; j++){
			if (st[j] > st[j + 1])
			{
				tmp = st[j];
				st[j] = st[j + 1];
				st[j + 1] = tmp;
			}
		}
	}
	printf("Rendezeve:\n");
	for (i = 0; i<TMERET; i++)
		printf("%.1lf ", st[i]);
	printf("\n");

	// statikus 2d-s tömb
	int tb[3][4] = { { 1, 2, 3, 4 },
	{ 2, 3, 4, 5 },
	{ 3, 4, 5, 6 } };

	// dinamikus 2D -tömb
	int sor = 3;
	int oszlop = 4;
	int** Matrix = (int**)malloc(sizeof(int*) * sor);
	for (int i = 0; i < sor; i++) 
		Matrix[i] = (int*)malloc(sizeof(int) * oszlop);
	// feltöltés
	for (int i = 0; i < sor; i++)
		for (int j = 0; j < oszlop; j++)
			if (i == j) Matrix[i][j] = 1;
			else 		Matrix[i][j] = 0;
	// kiírás
	for (int i = 0; i < sor; i++)
	{
		for (int j = 0; j < oszlop; j++) printf("%5i", Matrix[i][j]);
		printf("\n");
	}
	// felszabadítás fordított sorrendben
	for (int i = 0; i < sor; i++)
		free(Matrix[i]);
	free(Matrix);

	//typedef használata
	byte mask = 1 << 2;

	// statikus struktúra
	struct p2D P;
	// adatok elérése
	P.x = 5;
	P.y = 5;

	// typedef használatával
	pixel_t Origo;
	Origo.x = 5;

	// dinamikus struktúra
	struct p2D * Pont = (struct p2D *) malloc(sizeof(struct p2D));
	
	(*Pont).x = 3;
	Pont->y = 5;

	free(Pont);

	// 2 pontnak foglalok le helyet 
	struct p2D* Szakasz = (struct p2D *) malloc(2*sizeof(struct p2D));

	Szakasz[0].x = 1;
	(Szakasz + 0)->y = 2;
	(Szakasz + 1)->x = 3;
	(*(Szakasz + 1)).x = 4;
	
	// HF: mekkora a két pont távolsága?

	free(Szakasz);

	return 0;
}

#include <stdio.h>   // printf, scanf(_s)
#include <stdlib.h>  // RANAD_MAX, malloc
#include <math.h>    // matematikai készlet
#include <time.h>    // time

//Függvények prototípusa            //.h fájlban a helyük
double szumma(double, double, double);
void haromszoros(double);
void csere_a(int a, int b);
void csere_p(int* a, int* b);
//tömb átadása
double tatlag(double* t, int n); // pointer + méret
void tkiir(double* t, int n); // pointer + méret

//2D-s pont
struct p2D
{
	double x;
	double y;
};

struct p2D felez(struct p2D A, struct  p2D B);
void kiir(struct p2D P);    // érték szerinti paraméter átadás
void torol(struct p2D* P);  // pointeres, hogy meg lehessen változtatni

double szakaszhossz(struct p2D* szakszhossz, int meret);

int main(void)
{
	// véletlen szám generátor
	srand((unsigned int)time(NULL));

	int a = 5;
	int b = 10;

	// függvények hívása
	double c = szumma(a, b, 3);
	
	if (isnan(c)) //értelmes-e a visszakapott adat?
		printf("Nincs megoldas\n");
	else 
		haromszoros(c);

	// nem működik
	csere_a(a, b);                      // csak érték átadás történik
	printf("a: %i b: %i\n", a, b);

	// pointeres verzió
	csere_p(&a, &b);                    // az adatok címét kell megadni
	printf("a: %i b: %i\n", a, b);

	int meret;
	printf("Dinamikus tomb merete:");
	scanf("%d", &meret);                // menet közben derül ki, mennyi elemre is van szükség

	double* t = (double*)malloc(sizeof(double) * meret); // dinamikus tömb

	for (int i = 0; i < meret; i++)
		t[i] = (double)rand() / RAND_MAX * 1000 - 500;  // -500 és 500 közötti

	printf("Atlag: %3.2lf\n", tatlag(t, meret));        // tömb átadása fgv.-nek
								
	// statikus struktúrák
	struct p2D A = { 10,20 };
	struct p2D B, C;

	B.x = 0;
	B.y = 10;

	C = felez(A, B);        // fgv. hívása
	struct p2D* D = &C;     // pointer

	printf("Fele [%.2lf;%.2lf]\n", C.x, C.y);
	printf("Fele [%.2lf;%.2lf]\n", (*D).x, D->y);

	kiir(C);
	kiir(*D);

	torol(&C);
	torol(D);

	// HF szakasz hossza

	// dinamikus tömb
	struct p2D* szakasz = (struct p2D*)malloc(sizeof(struct p2D) * meret);
	for (int i = 0; i < meret; i++)
	{
		szakasz[i].x = i;       // így is lehetne: (*(szakasz + i)).x = i;
		szakasz[i].y = t[i];    // így is lehetne: (szakasz + i)->y = t[i];
	}

	// függvény segítségével határozzuk meg a szakaszok hosszát
	printf("A szakaszok hossza: %.3lf\n", szakaszhossz(szakasz, meret));

	// dinamikus tartalmak felszabadítása
	free(t);
	free(szakasz);

	return 0;
}

// függvény visszatérési értékkel
double szumma(double a, double b, double c)
{
	if (a < 0) return NAN;  // ha nincs értelmes visszatérési érték, akkor Not a Number-el tér vissza
	return a + b + c;
}

// eljárás (nincs visszatérési értéke)
void haromszoros(double szam)
{
	printf("A szam haromszorosa: %lf", szam * 3);
}

// érték szerinti paraméter átadás
void csere_a(int a, int b)        //a és b lokális egész számok
{
	int tmp = a; a = b; b = tmp;
}

// mutató használata
void csere_p(int* a, int* b)        //a és b egészre mutató pointerek
{
	int tmp = *a; *a = *b; *b = tmp;
}

// double tomb átlagát adja
double tatlag(double* t, int n)
{
	double summa = 0;
	for (int i = 0; i < n; i++) summa += t[i];
	return summa / n;
}

// double tomb elemeit írja ki
void tkiir(double* t, int n)
{
	for (int i = 0; i < n; i++) printf("%f\n",t[i]);
}

// 2 pont felezőpontja
struct p2D felez(struct p2D A, struct  p2D B)
{
	struct p2D fele;
	fele.x = (A.x + B.x) / 2;
	fele.y = (A.y + B.y) / 2;
	return fele;
}

// point koordinátáinak kiírása
void kiir(struct p2D P)
{
	printf("[%.2f;%.2f]", P.x, P.y);
}

// point koordinátái 0,0
void torol(struct p2D* P)
{
	P->x = 0;
	(*P).y = 0;
}

// szakaszok hossza
double szakaszhossz(struct p2D* P, int meret)
{
	double hossz = 0;
	for (int i = 0; i < meret - 1; i++)
		hossz += sqrt(pow(P[i].x - P[i + 1].x, 2) + pow(P[i].y - P[i + 1].y, 2));
	return hossz;
}

		

		
// Hamarosan ...