// 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;
		
		

		
// Hamarosan