B-PROG2 Materiály 2019

Materiály z roku 2019

/*Globalne a lokalne premenne*/

#include <stdio.h>

//globalna premenna: kazdy ju moze citat a modifikovat
int x = 3;

//void: bezhodnotovy typ
void fun1(void)
{
	printf("Fun1: %i\n", x);
}

void fun2(int x)
{
	//lokalny parameter x nahradi globalnu premennu x
	printf("Fun2: %i\n", x);
}

int main()
{
	int x = 2;
	//lokalna premenna x nahradi globalnu premennu x
	
	printf("main: %i\n", x);
	
	//TODO: co sa zmeni, ak dam fun1(x), fun2(x)?
	fun1();
	fun2(7);
	
	return 0;
}

/*Globalne a lokalne premenne*/

#include <stdio.h>

//globalna premenna: kazdy ju moze citat a modifikovat

int x = 3;

//void: bezhodnotovy typ

void fun1(void)

{

printf("Fun1: %i\n", x);

}

void fun2(int x)

{

//lokalny parameter x nahradi globalnu premennu x

printf("Fun2: %i\n", x);

}

int main()

{

int x = 2;

//lokalna premenna x nahradi globalnu premennu x

printf("main: %i\n", x);

//TODO: co sa zmeni, ak dam fun1(x), fun2(x)?

fun1();

fun2(7);

return 0;

}

/* Demo01: Celocislene delenie */
#include <stdio.h>

int main( )
{
	int a, b, c;

	while ( 1 == 1 )
	{
		printf("Zadaj 2 cisla:");
		scanf("%d", &a);
		scanf("%d", &b);
		
		if (b == 0)
		{
			return -1;
		}
		
		c = a/ b;
		printf("%i / %i = %i\n", a, b, c);

		c = a % b;
		printf("%i mod %i = %i\n", a, b, c);
		
	}
    return 0;
}

/* Demo01: Celocislene delenie */

#include <stdio.h>

int main( )

{

int a, b, c;

while ( 1 == 1 )

{

printf("Zadaj 2 cisla:");

scanf("%d", &a);

scanf("%d", &b);

if (b == 0)

{

return -1;

}

c = a/ b;

printf("%i / %i = %i\n", a, b, c);

c = a % b;

printf("%i mod %i = %i\n", a, b, c);

}

return 0;

}

/* Demo02: Floating point delenie */
#include <stdio.h>

int main( )
{
	double a, b, c = 3.4e-3;

	while ( 1 == 1 )
	{
		printf("Zadaj 2 cisla:");
		scanf("%lf", &a);
		scanf("%lf", &b);
		
		if (b == 0.0)
			return -1;
		
		c = a / b;
		printf("%lf / %lf = %lf\n", a, b, c);

		//c = a % b;
		//printf("%lf mod %lf = %lf\n", a, b, c);
		
	}
    return 0;
}

/* Demo02: Floating point delenie */

#include <stdio.h>

int main( )

{

double a, b, c = 3.4e-3;

while ( 1 == 1 )

{

printf("Zadaj 2 cisla:");

scanf("%lf", &a);

scanf("%lf", &b);

if (b == 0.0)

return -1;

c = a / b;

printf("%lf / %lf = %lf\n", a, b, c);

//c = a % b;

//printf("%lf mod %lf = %lf\n", a, b, c);

}

return 0;

}

/* Konverzia datovych typov:
   explicitna: operator (TYP)
   implicitna: 
     podla pravidiel zo standardu: 
	   a) na spolocny vacsi typ
	   b) podla typu premennej, kam sa zapisuje
 */
#include <stdio.h>

int main( )
{
	int a, b, c;
	double x, y, z;

	while ( 1 == 1 )
	{
		printf("Zadaj 2 cisla:");
		scanf("%d", &a);
		scanf("%d", &b);
		
		if (b == 0)
			return -1;
		
		c = a / b;
		printf("Celociselne: %i / %i = %i\n", a, b, c);

		c = a % b;
		printf("Zvysok: %i mod %i = %i\n", a, b, c);
		
		//x = (double) a; y = (double) b;
		//z = x / y;
		z = a / (double) b;
		
		printf("Necelociselne: %.0lf / %.0lf = %lf\n", 
		                      (double)a, (double)b, z);
		
		z = (int) (z+0.5);
		printf("Zaokruhlene: %lf\n", z);
		
	}
    return 0;
}

/* Konverzia datovych typov:

explicitna: operator (TYP)

implicitna:

podla pravidiel zo standardu:

a) na spolocny vacsi typ

b) podla typu premennej, kam sa zapisuje

#include <stdio.h>

int main( )

{

int a, b, c;

double x, y, z;

while ( 1 == 1 )

{

printf("Zadaj 2 cisla:");

scanf("%d", &a);

scanf("%d", &b);

if (b == 0)

return -1;

c = a / b;

printf("Celociselne: %i / %i = %i\n", a, b, c);

c = a % b;

printf("Zvysok: %i mod %i = %i\n", a, b, c);

//x = (double) a; y = (double) b;

//z = x / y;

z = a / (double) b;

printf("Necelociselne: %.0lf / %.0lf = %lf\n",

(double)a, (double)b, z);

z = (int) (z+0.5);

printf("Zaokruhlene: %lf\n", z);

}

return 0;

}

/* Demo03: Rozne celociselne typy */
#include <stdio.h>
#include <stdint.h>    // doplnkove definicie typov
#include <limits.h>    // pomocne konstanty - rozsahy typu

//vlastna definicia typu:
typedef unsigned short int word;

int main( )
{
	int                iP1  = -1;
	short int          siP2 = 100000;         //pretecenie
	char               cP3  = 65;             //cislo aj znak (default: ASCII kodovane)
	unsigned long int  ulP4 = 0xdeadbeef;     //hexa zadana konstanta 
    unsigned long long llP5 = -1;             //int sa da vynechat, -1 sa skonvertuje na unsigned
	word               wP6  = 0100;           //nas vlastny typ, osmickova sustava 
    int64_t            qwP7 = -1;             //alternativna definicia z stdint.h
        
    //TODO: priradit spravne format stringy
    printf("1. %i, size = %iB\n",  iP1, sizeof(iP1));
    printf("2. %i, size = %iB\n", siP2, sizeof(siP2));
    printf("3. %i, size = %iB\n",  cP3, sizeof(cP3));
    printf("4. %i, size = %iB\n", ulP4, sizeof(ulP4));
    printf("5. %i, size = %iB\n", llP5, sizeof(llP5));
    printf("6. %i, size = %iB\n",  wP6, sizeof(wP6));
    printf("7. %i, size = %iB\n", qwP7, sizeof(qwP7));
   
    //TODO: ostatne typy
    printf("Hranice int: od %i do %i\n", INT_MIN, INT_MAX);

    return 0;
}

/* Demo03: Rozne celociselne typy */

#include <stdio.h>

#include <stdint.h> // doplnkove definicie typov

#include <limits.h> // pomocne konstanty - rozsahy typu

//vlastna definicia typu:

typedef unsigned short int word;

int main( )

{

int iP1 = -1;

short int siP2 = 100000; //pretecenie

char cP3 = 65; //cislo aj znak (default: ASCII kodovane)

unsigned long int ulP4 = 0xdeadbeef; //hexa zadana konstanta

unsigned long long llP5 = -1; //int sa da vynechat, -1 sa skonvertuje na unsigned

word wP6 = 0100; //nas vlastny typ, osmickova sustava

int64_t qwP7 = -1; //alternativna definicia z stdint.h

//TODO: priradit spravne format stringy

printf("1. %i, size = %iB\n", iP1, sizeof(iP1));

printf("2. %i, size = %iB\n", siP2, sizeof(siP2));

printf("3. %i, size = %iB\n", cP3, sizeof(cP3));

printf("4. %i, size = %iB\n", ulP4, sizeof(ulP4));

printf("5. %i, size = %iB\n", llP5, sizeof(llP5));

printf("6. %i, size = %iB\n", wP6, sizeof(wP6));

printf("7. %i, size = %iB\n", qwP7, sizeof(qwP7));

//TODO: ostatne typy

printf("Hranice int: od %i do %i\n", INT_MIN, INT_MAX);

return 0;

}

/* Demo04: Floating point typy */
#include <stdio.h>
#include <float.h>

int main( )
{
	float  fx = 0.01;
	double dx = 0.01;
 
    printf("The maximum value of float = %.10e\n", FLT_MAX);
    printf("The minimum value of float = %.10e\n", FLT_MIN);

    printf("The maximum value of double = %.10e\n", DBL_MAX);
    printf("The minimum value of double = %.10e\n", DBL_MIN);

    printf("Float : %0.3f = %0.30f\n", fx, fx);
    printf("Double: %0.3lf = %0.308lf\n", dx, dx);

    return 0;
}

/* Demo04: Floating point typy */

#include <stdio.h>

#include <float.h>

int main( )

{

float fx = 0.01;

double dx = 0.01;

printf("The maximum value of float = %.10e\n", FLT_MAX);

printf("The minimum value of float = %.10e\n", FLT_MIN);

printf("The maximum value of double = %.10e\n", DBL_MAX);

printf("The minimum value of double = %.10e\n", DBL_MIN);

printf("Float : %0.3f = %0.30f\n", fx, fx);

printf("Double: %0.3lf = %0.308lf\n", dx, dx);

return 0;

}

/*Ukazka: je potrebne mat spravne typy pri stdio funkciach
     ak zle printf: hodnoty sa nespravne vypisu
	 ak zle scanf: hodnoty sa nespravne nacitaju
	               moze dojst k padu programu (nedostatok pamate) 
 */

#include <stdio.h>

int main()
{
	int a, b, c;
	double x, y, z;
	
	printf("x? ");
	scanf("%lf", &x);
	
	a = (int)x;
	
	printf("x %%i: %i\n", x);
	printf("x %%f: %lf\n", x);
	printf("a %%i: %i\n", a);
	printf("a %%f: %lf\n", a);
	
	
	return 0;
}

/*Ukazka: je potrebne mat spravne typy pri stdio funkciach

ak zle printf: hodnoty sa nespravne vypisu

ak zle scanf: hodnoty sa nespravne nacitaju

moze dojst k padu programu (nedostatok pamate)

#include <stdio.h>

int main()

{

int a, b, c;

double x, y, z;

printf("x? ");

scanf("%lf", &x);

a = (int)x;

printf("x %%i: %i\n", x);

printf("x %%f: %lf\n", x);

printf("a %%i: %i\n", a);

printf("a %%f: %lf\n", a);

return 0;

}

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

//pozn.: nie je to presne, zavisi na nasom programe...
#define FPS          30

// Podmieneny preklad: verzia pre WINDOWS sa lisi od LINUX verzie
//    - pomozeme si s makrami a podmienenym prekladom:
//       Sleep/usleep uspi program na dany pocet ms
//       premazanie obrazovky -> bud program cls, alebo tzv. escape sequence [2J
#ifdef _WIN32
 #include <windows.h>
 #define PAUSE()              Sleep(1000/FPS)
 #define CLEAR_SCREEN()       system("cls")
#else
 #include <unistd.h>
 #define PAUSE()              usleep(1000/FPS)
 #define CLEAR_SCREEN()       printf("\x1b[2J");
#endif

void vypis_obrazovky_old(int pozicia)
{
	printf("%*c\n", pozicia, 'o');
	printf("%*c|-\n", pozicia-1, '-');
	//printf("%*c\n", pozicia, '|');
	printf("%*c \\\n", pozicia-1, '/');
	
}

#define RIADKY 20
#define STLPCE 60

int je_ramcek(int riadok, int znak)
{
	if ( riadok == 0 || riadok == RIADKY - 1 )
		return 1;
		
	if ( znak == 0 || znak == STLPCE - 1 )
		return 2;
	return 0;
}

int som_vnutri_kruhu(int riadok, int znak, int polomer)
{
	int dx = znak - STLPCE/2;
	int dy = riadok - RIADKY/2;
	double distance = sqrt(dx*dx + dy*dy);
	return distance <= polomer;
}

void vypis_obrazovky(int pozicia)
{
	int riadok, znak;
	
	for (riadok = 0; riadok < RIADKY; riadok++)
	{
		
		
		for (znak = 0; znak < STLPCE; znak++)
		{
			if (je_ramcek(riadok, znak))
				printf("+");
			else if (som_vnutri_kruhu(riadok, znak, pozicia))
				printf("*");
			else
				printf(" ");
		}
		
		printf("\n");
	}
	
}

int main()
{
	int pos = 10;
	while (1 == 1)
	{
		vypis_obrazovky(pos);
		
		
		pos += 2*(rand()%2)-1;
		
		PAUSE();
		CLEAR_SCREEN();
	}
	
	
	return 0;
}

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

//pozn.: nie je to presne, zavisi na nasom programe...

#define FPS 30

// Podmieneny preklad: verzia pre WINDOWS sa lisi od LINUX verzie

// - pomozeme si s makrami a podmienenym prekladom:

// Sleep/usleep uspi program na dany pocet ms

// premazanie obrazovky -> bud program cls, alebo tzv. escape sequence [2J

#ifdef _WIN32

#include <windows.h>

#define PAUSE() Sleep(1000/FPS)

#define CLEAR_SCREEN() system("cls")

#else

#include <unistd.h>

#define PAUSE() usleep(1000/FPS)

#define CLEAR_SCREEN() printf("\x1b[2J");

#endif

void vypis_obrazovky_old(int pozicia)

{

printf("%*c\n", pozicia, 'o');

printf("%*c|-\n", pozicia-1, '-');

//printf("%*c\n", pozicia, '|');

printf("%*c \\\n", pozicia-1, '/');

}

#define RIADKY 20

#define STLPCE 60

int je_ramcek(int riadok, int znak)

{

if ( riadok == 0 || riadok == RIADKY - 1 )

return 1;

if ( znak == 0 || znak == STLPCE - 1 )

return 2;

return 0;

}

int som_vnutri_kruhu(int riadok, int znak, int polomer)

{

int dx = znak - STLPCE/2;

int dy = riadok - RIADKY/2;

double distance = sqrt(dx*dx + dy*dy);

return distance <= polomer;

}

void vypis_obrazovky(int pozicia)

{

int riadok, znak;

for (riadok = 0; riadok < RIADKY; riadok++)

{

for (znak = 0; znak < STLPCE; znak++)

{

if (je_ramcek(riadok, znak))

printf("+");

else if (som_vnutri_kruhu(riadok, znak, pozicia))

printf("*");

else

printf(" ");

}

printf("\n");

}

int main()

{

int pos = 10;

while (1 == 1)

{

vypis_obrazovky(pos);

pos += 2*(rand()%2)-1;

PAUSE();

CLEAR_SCREEN();

}

return 0;

}

#include <stdio.h>

//vrati pocet dni v mesiaci (cislovane od 1)
int pocet_dni(int mesiac)
{
	int pocet = 0;
	if (1 == mesiac || 3 == mesiac || 5 == mesiac)
	{
		pocet = 31;
	}
	else if (2 == mesiac)
	{
		pocet = 28;
	}
	else if (4 == mesiac || 6 == mesiac)
	{
		pocet = 30;
	}
	
	return pocet;
}

//pre kazdy mesiac, vypis pocet dni
void vypis_dni()
{
	int mesiac;
	
	//inicializacia pred cyklom
	mesiac = 1;
	
	//CYKLUS s podmienkou
	while (mesiac <= 12)
	{
		//telo cyklu
		printf("Mesiac c. %2d ma %2d dni.\n",
		                mesiac, pocet_dni(mesiac));
		
		//AKTUALIZACIA premennej cyklu
		mesiac++;    //aka: mesiac = mesiac + 1;
	}
	
	//finalizacia za cyklom
}

int main()
{
	vypis_dni();
	return 0;
}

#include <stdio.h>

//vrati pocet dni v mesiaci (cislovane od 1)

int pocet_dni(int mesiac)

{

int pocet = 0;

if (1 == mesiac || 3 == mesiac || 5 == mesiac)

{

pocet = 31;

}

else if (2 == mesiac)

{

pocet = 28;

}

else if (4 == mesiac || 6 == mesiac)

{

pocet = 30;

}

return pocet;

}

//pre kazdy mesiac, vypis pocet dni

void vypis_dni()

{

int mesiac;

//inicializacia pred cyklom

mesiac = 1;

//CYKLUS s podmienkou

while (mesiac <= 12)

{

//telo cyklu

printf("Mesiac c. %2d ma %2d dni.\n",

mesiac, pocet_dni(mesiac));

//AKTUALIZACIA premennej cyklu

mesiac++; //aka: mesiac = mesiac + 1;

}

//finalizacia za cyklom

}

int main()

{

vypis_dni();

return 0;

}

#include <stdio.h>

//vrati pocet dni v mesiaci (cislovane od 1)
int pocet_dni(int mesiac)
{
	int pocet = 0;
	
	switch (mesiac)
	{
		case 2:
			pocet = 28;  // pocet = 28 + jeprestupny(rok)
			break;
		case 1:
		case 3:
		case 5:
		case 7:
		case 8:
		case 10:
		case 12:
			pocet = 31;
			break;
		default:
			pocet = 30;
			break;
	}
	
	return pocet;
}

//pre kazdy mesiac, vypis pocet dni
void vypis_dni()
{
	int mesiac;
	
	//inicializacia pred cyklom
	mesiac = 1;
	
	//CYKLUS s podmienkou
	while (mesiac <= 12)
	{
		//telo cyklu
		printf("Mesiac c. %2d ma %2d dni.\n",
		                mesiac, pocet_dni(mesiac));
		
		//AKTUALIZACIA premennej cyklu
		mesiac++;    //aka: mesiac = mesiac + 1;
	}
	
	//finalizacia za cyklom
}

int main()
{
	vypis_dni();
	return 0;
}

#include <stdio.h>

//vrati pocet dni v mesiaci (cislovane od 1)

int pocet_dni(int mesiac)

{

int pocet = 0;

switch (mesiac)

{

case 2:

pocet = 28; // pocet = 28 + jeprestupny(rok)

break;

case 1:

case 3:

case 5:

case 7:

case 8:

case 10:

case 12:

pocet = 31;

break;

default:

pocet = 30;

break;

}

return pocet;

}

//pre kazdy mesiac, vypis pocet dni

void vypis_dni()

{

int mesiac;

//inicializacia pred cyklom

mesiac = 1;

//CYKLUS s podmienkou

while (mesiac <= 12)

{

//telo cyklu

printf("Mesiac c. %2d ma %2d dni.\n",

mesiac, pocet_dni(mesiac));

//AKTUALIZACIA premennej cyklu

mesiac++; //aka: mesiac = mesiac + 1;

}

//finalizacia za cyklom

}

int main()

{

vypis_dni();

return 0;

}

#include <stdio.h>

//vrati pocet dni v mesiaci (cislovane od 1)
int pocet_dni(int mesiac)
{
	//TODO:
	return 30;
}

//pre kazdy mesiac, vypis pocet dni
void vypis_dni()
{
	int mesiac;
	//inicializacia pred cyklom
	for (mesiac =  1 ; mesiac <= 12 ; mesiac++)
	{
		//telo cyklu
		printf("Mesiac c. %2d ma %2d dni.\n",
		                mesiac, pocet_dni(mesiac));
	}	
	//finalizacia za cyklom
}

int main()
{
	vypis_dni();
	return 0;
}

#include <stdio.h>

//vrati pocet dni v mesiaci (cislovane od 1)

int pocet_dni(int mesiac)

{

//TODO:

return 30;

}

//pre kazdy mesiac, vypis pocet dni

void vypis_dni()

{

int mesiac;

//inicializacia pred cyklom

for (mesiac = 1 ; mesiac <= 12 ; mesiac++)

{

//telo cyklu

printf("Mesiac c. %2d ma %2d dni.\n",

mesiac, pocet_dni(mesiac));

}

//finalizacia za cyklom

}

int main()

{

vypis_dni();

return 0;

}

#include <stdio.h>

//vrati pocet dni v mesiaci (cislovane od 1)
int pocet_dni(int mesiac)
{
	//TODO:
	return 30;
}

//nacita mesiac a vypise jeho pocet dni, 
// vrati 0, ak zlyhalo nacitanie mesiaca
int vypis_dni()
{
	int mesiac;
	
	//TODO: overit nacitanie?
	do
	{
		printf("Zadaj cislo mesiaca: ");
		scanf("%d", &mesiac);
		
		if (mesiac < 1 || mesiac > 12)
			return 0;
			
		printf("Mesiac c. %2d ma %2d dni.\n",
		            mesiac, pocet_dni(mesiac));
	} while (1 == 1);
	
	return 1;	
}

int main()
{
	//prazdny cyklus?
	vypis_dni();
		
	return 0;
}

#include <stdio.h>

//vrati pocet dni v mesiaci (cislovane od 1)

int pocet_dni(int mesiac)

{

//TODO:

return 30;

}

//nacita mesiac a vypise jeho pocet dni,

// vrati 0, ak zlyhalo nacitanie mesiaca

int vypis_dni()

{

int mesiac;

//TODO: overit nacitanie?

{

printf("Zadaj cislo mesiaca: ");

scanf("%d", &mesiac);

if (mesiac < 1 || mesiac > 12)

return 0;

printf("Mesiac c. %2d ma %2d dni.\n",

mesiac, pocet_dni(mesiac));

} while (1 == 1);

return 1;

}

int main()

{

//prazdny cyklus?

vypis_dni();

return 0;

}

#include <stdio.h>

//vrati pocet dni v mesiaci (cislovane od 1)
int pocet_dni(int mesiac)
{
	return 30 + 
	       ((mesiac + (mesiac > 7)) % 2) 
		   - 2*(mesiac == 2);
}

void znaky(int pocet, char znak, int eol)
{
	int i;
	for (i = pocet; i > 0; i--)
	{
		printf("%c", znak);
	}
	if (eol)
	{
		printf("\n");
	}
}

void hviezdicky(int pocet)
{
	int i;
	for (i = pocet; i > 0; i--)
	{
		printf("*");
	}
	printf("\n");
}

//pre kazdy mesiac, vypis pocet dni
void vypis_dni()
{
	int mesiac, dni;
	
	for (mesiac = 1; mesiac <= 12; mesiac++)
	{
		printf("%2d: ", mesiac);
		
		hviezdicky(pocet_dni(mesiac));

	}
}

void pyramida(int podstava)
{
	int pocet;
	
	for (pocet = 1; pocet <= podstava; pocet+=2)
	{
		znaky((podstava-pocet)/2, ' ', 0);
		znaky(pocet, 'o', 1);
	}	
}

void trojuholnik(int podstava)
{
	int pocet;
	
	for (pocet = 1; pocet <= podstava; pocet++)
	{
		hviezdicky(pocet);
	}	
}

int main()
{
	int i;
	for (i = 0; i < 3; i++)
		pyramida(7);
	return 0;
}

#include <stdio.h>

//vrati pocet dni v mesiaci (cislovane od 1)

int pocet_dni(int mesiac)

{

return 30 +

((mesiac + (mesiac > 7)) % 2)

- 2*(mesiac == 2);

}

void znaky(int pocet, char znak, int eol)

{

int i;

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

{

printf("%c", znak);

}

if (eol)

{

printf("\n");

}

void hviezdicky(int pocet)

{

int i;

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

{

printf("*");

}

printf("\n");

}

//pre kazdy mesiac, vypis pocet dni

void vypis_dni()

{

int mesiac, dni;

for (mesiac = 1; mesiac <= 12; mesiac++)

{

printf("%2d: ", mesiac);

hviezdicky(pocet_dni(mesiac));

}

void pyramida(int podstava)

{

int pocet;

for (pocet = 1; pocet <= podstava; pocet+=2)

{

znaky((podstava-pocet)/2, ' ', 0);

znaky(pocet, 'o', 1);

}

void trojuholnik(int podstava)

{

int pocet;

for (pocet = 1; pocet <= podstava; pocet++)

{

hviezdicky(pocet);

}

int main()

{

int i;

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

pyramida(7);

return 0;

}

Použitie polí

Polia predstavujú postupnosť za sebou v pamäti uložených údajov sprístupniteľných cez index.

//deklaracia pola, nedefinovany obsah, maximum KAPACITA prvkov
TYP NAZOV[KAPACITA];   

//deklaracia pola s vymenovanim prvkov, KAPACITA sa moze, ale nemusi vynechat
int prvocisla[] = {2,3,5,7,11,13,17};

//spristupnenie prvku - operator indexovania - indexy od nuly po KAPACITA-1
a = pole[0];  //precita sa prvy prvok a zapise do premennej a
pole[i] = a;  //obsah premennej a sa zapise do pola na index ulozeny v premennej i

//deklaracia pola, nedefinovany obsah, maximum KAPACITA prvkov

TYP NAZOV[KAPACITA];

//deklaracia pola s vymenovanim prvkov, KAPACITA sa moze, ale nemusi vynechat

int prvocisla[] = {2,3,5,7,11,13,17};

//spristupnenie prvku - operator indexovania - indexy od nuly po KAPACITA-1

a = pole[0]; //precita sa prvy prvok a zapise do premennej a

pole[i] = a; //obsah premennej a sa zapise do pola na index ulozeny v premennej i

Viac detailov k inicializácii: http://en.cppreference.com/w/c/language/array_initialization

Viacrozmerné polia

Štandardne polia, ktorých prvkami sú iné polia.

//pole troch poli, z ktorych kazde ma 5 prvkov typu int
int pole2D[3][5];   

//pole NS stranok po NR riadkoch po NC+1 znakoch kazdy riadok
char kniha[NS][NR][NC+1];

//pole troch poli, z ktorych kazde ma 5 prvkov typu int

int pole2D[3][5];

//pole NS stranok po NR riadkoch po NC+1 znakoch kazdy riadok

char kniha[NS][NR][NC+1];

Funkcia na výpis obsahu poľa

#include <stdio.h>

//funkcia vypise obsah pola, verzia pre int polia
void vypis_pole(const int pole[], int n)
{
    int i;
    printf("Velkost pola: %i\n", n);
    for (i = 0; i < n; i++)
    {
        printf("%lf ", pole[i]);
    }
    printf("\n");
}

//priklady pouzitia 
int main()
{
    int pole[] = {1,2,3,4,5};
    int n = sizeof(pole)/sizeof(pole[0]); //iba tam, kde je pole deklarovane

    //vypise cele pole
    vypis_pole(pole, n);

    //vypise prve 3 prvky
    vypis_pole(pole, 3);

    //vypise posledne 2 prvky
    vypis_pole(pole+n-2, 2);

    return 0;
}

#include <stdio.h>

//funkcia vypise obsah pola, verzia pre int polia

void vypis_pole(const int pole[], int n)

{

int i;

printf("Velkost pola: %i\n", n);

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

{

printf("%lf ", pole[i]);

}

printf("\n");

}

//priklady pouzitia

int main()

{

int pole[] = {1,2,3,4,5};

int n = sizeof(pole)/sizeof(pole[0]); //iba tam, kde je pole deklarovane

//vypise cele pole

vypis_pole(pole, n);

//vypise prve 3 prvky

vypis_pole(pole, 3);

//vypise posledne 2 prvky

vypis_pole(pole+n-2, 2);

return 0;

}

Funkcia na načítanie údajov do poľa

#include <stdio.h>
#define MAXPOLE 100

//vstupom je adresa pola, kam sa nacitava (verzia pre double)
// a adresa premennej, kde sa uchovava velkost pola: 
//   * pred funkciou musi byt maximum, co sa da ulozit
//   * po funkcii bude mat pocet aktualne ulozenych udajov
void nacitaj_pole(double pole[], int *pN)
{
    int i, n;
    do
    {
       printf("Zadaj kolko prvkov\n");
       scanf("%i", &n);
    } while (n > *pN);    //kontrola pretecenia

    // nacitanie obsahu
    for (i = 0; i < n; i++)
    {
        scanf("%lf", &pole[i]);
    }
    //ulozenie novej dlzky pola
    *pN = n;
}

//priklad pouzitia
int main()
{
    double field[MAXPOLE];
    int n = sizeof(field)/sizeof(field[0]);
 
    nacitaj_pole(field, &n);
    vypis_pole(field, n);

    return 0;
}

#include <stdio.h>

#define MAXPOLE 100

//vstupom je adresa pola, kam sa nacitava (verzia pre double)

// a adresa premennej, kde sa uchovava velkost pola:

// * pred funkciou musi byt maximum, co sa da ulozit

// * po funkcii bude mat pocet aktualne ulozenych udajov

void nacitaj_pole(double pole[], int *pN)

{

int i, n;

{

printf("Zadaj kolko prvkov\n");

scanf("%i", &n);

} while (n > *pN); //kontrola pretecenia

// nacitanie obsahu

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

{

scanf("%lf", &pole[i]);

}

//ulozenie novej dlzky pola

*pN = n;

}

//priklad pouzitia

int main()

{

double field[MAXPOLE];

int n = sizeof(field)/sizeof(field[0]);

nacitaj_pole(field, &n);

vypis_pole(field, n);

return 0;

}

Funkcia na kopírovanie obsahu poľa

#include <stdio.h>
#include <memory.h>
#define MAXPOLE 100

//vstupom su adresy poli, a pocet poloziek, ktore sa kopiruju
//  POZOR na mozne pretecenie
void kopiruj(int ciel[], int zdroj[], int n)
{
    int i;
    for (i = 0; i < n; i++)
    {
        ciel[i] = zdroj[i];
    }
}

//priklad pouzitia
int main()
{
    int pole1[MAXPOLE], pole2[MAXPOLE];
    int n1 = sizeof(pole1)/sizeof(pole1[0]);
    int n2;
 
    nacitaj_pole(pole1, &n1);
    
    n2 = n1;
    kopiruj(pole2, pole1, n2);
    
    //to iste cez kniznicnu funkciu:
    memcpy(pole2, pole1, n2*sizeof(pole1[0]));

    vypis_pole(pole2, n2);
 
    return 0;
}

#include <stdio.h>

#include <memory.h>

#define MAXPOLE 100

//vstupom su adresy poli, a pocet poloziek, ktore sa kopiruju

// POZOR na mozne pretecenie

void kopiruj(int ciel[], int zdroj[], int n)

{

int i;

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

{

ciel[i] = zdroj[i];

}

//priklad pouzitia

int main()

{

int pole1[MAXPOLE], pole2[MAXPOLE];

int n1 = sizeof(pole1)/sizeof(pole1[0]);

int n2;

nacitaj_pole(pole1, &n1);

n2 = n1;

kopiruj(pole2, pole1, n2);

//to iste cez kniznicnu funkciu:

memcpy(pole2, pole1, n2*sizeof(pole1[0]));

vypis_pole(pole2, n2);

return 0;

}

Funkcia na porovnanie obsahu polí

#include <stdio.h>
#include <memory.h>
#define MAXPOLE 100

//vstupom su adresy poli, a pocet poloziek, ktore sa porovnavaju
// vracia iba 0/1 (zhoda/nezhoda)
int porovnaj(int pole1[], int pole2[], int n)
{
    int i;
    for (i = 0; i < n; i++)
    {
        if (pole1[i] != pole2[i])
            return 0;
    }
    return 1;
}
//priklad pouzitia
int main()
{
    int pole1[MAXPOLE], pole2[MAXPOLE];
    int n1 = sizeof(pole1)/sizeof(pole1[0]);
    int n2 = sizeof(pole2)/sizeof(pole2[0]);
    int minn;
 
    nacitaj_pole(pole1, &n1);
    nacitaj_pole(pole2, &n2);
    
    minn = n1 < n2 ? n1 : n2;
    if (porovnaj(pole1, pole2, minn))
       printf("Zhodny obsah\n");    

    //to iste cez kniznicnu funkciu:
    if (memcmp(pole1, pole2, minn*sizeof(pole1[0])) == 0)   //vracia 0 iba v pripade zhody
       printf("Zhodny obsah\n");        
 
    return 0;
}

#include <stdio.h>

#include <memory.h>

#define MAXPOLE 100

//vstupom su adresy poli, a pocet poloziek, ktore sa porovnavaju

// vracia iba 0/1 (zhoda/nezhoda)

int porovnaj(int pole1[], int pole2[], int n)

{

int i;

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

{

if (pole1[i] != pole2[i])

return 0;

}

return 1;

}

//priklad pouzitia

int main()

{

int pole1[MAXPOLE], pole2[MAXPOLE];

int n1 = sizeof(pole1)/sizeof(pole1[0]);

int n2 = sizeof(pole2)/sizeof(pole2[0]);

int minn;

nacitaj_pole(pole1, &n1);

nacitaj_pole(pole2, &n2);

minn = n1 < n2 ? n1 : n2;

if (porovnaj(pole1, pole2, minn))

printf("Zhodny obsah\n");

//to iste cez kniznicnu funkciu:

if (memcmp(pole1, pole2, minn*sizeof(pole1[0])) == 0) //vracia 0 iba v pripade zhody

printf("Zhodny obsah\n");

return 0;

}

Funkcia na vymazanie údajov z poľa

#include <stdio.h>
#define MAXPOLE 100

//ulohou funkcie je vymazat z pola vsetky vyskyty prvku x
//  pN je smernik na premennu, ktora drzi velkost pola (pred aj po vymazani)
//  vrati pocet vymazanych
int vymaz_vsetky(double pole[], int *pN, double x)
{
    int i, j, pocet = 0;
    for (i = 0; i < *pN; i++)
    {
        if (pole[i] == x)
        { 
            //pomaly variant s dvojitym cyklom
            for (j = i+1; j < *pN; j++)
            {
                //zoberiem hodnotu z j-tej pozicie a skopirujem ju na predoslu (j-1) poziciu
                //  v dalsom kroku cyklu sa to prepise nasledovnou hodnotou
                pole[j-1] = pole[j];
            }
            //zmenime pocet a skorigujeme index (lebo sme sa posunuli o jedna dozadu)
            *pN = *pN - 1;
            i--;
        }
    }
    return pocet;
}
int main()
{
    double field[MAXPOLE];
    int n;
    int total = sizeof(field)/sizeof(field[0]);
    
    n = total;
    nacitaj_pole(field, &n);
    
    vypis_pole(field, n);
    
    //vymaze vsetky vyskyty prveho prvku
    vymaz_vsetky(field, &n, field[0]);

    vypis_pole(field, n);

    return 0;
}

#include <stdio.h>

#define MAXPOLE 100

//ulohou funkcie je vymazat z pola vsetky vyskyty prvku x

// pN je smernik na premennu, ktora drzi velkost pola (pred aj po vymazani)

// vrati pocet vymazanych

int vymaz_vsetky(double pole[], int *pN, double x)

{

int i, j, pocet = 0;

for (i = 0; i < *pN; i++)

{

if (pole[i] == x)

{

//pomaly variant s dvojitym cyklom

for (j = i+1; j < *pN; j++)

{

//zoberiem hodnotu z j-tej pozicie a skopirujem ju na predoslu (j-1) poziciu

// v dalsom kroku cyklu sa to prepise nasledovnou hodnotou

pole[j-1] = pole[j];

}

//zmenime pocet a skorigujeme index (lebo sme sa posunuli o jedna dozadu)

*pN = *pN - 1;

i--;

}

return pocet;

}

int main()

{

double field[MAXPOLE];

int n;

int total = sizeof(field)/sizeof(field[0]);

n = total;

nacitaj_pole(field, &n);

vypis_pole(field, n);

//vymaze vsetky vyskyty prveho prvku

vymaz_vsetky(field, &n, field[0]);

vypis_pole(field, n);

return 0;

}

Príklady na polia

#include <stdio.h>

//vyuzijeme pole:
//PRE: 1 <= m && m <= 12
char* nazov_mesiaca(int m)
{
	char* mena[] = {"januar","februar","marec","april","maj","jun",
	                "jul","august","september","oktober","november","december"};
	
	return mena[m-1];
}


//vyuzijeme pole:
//PRE: 1 <= m && m <= 12
int pocet_dni(int m)
{	
	int pocty[] = {31,28,31,30,31,30,31,31,30,31,30,31};
	
	return pocty[m-1];
}

//TODO: 
// lokalne, globalne pole, staticke pole
// pole zadanej dlzky, pole premennej dlzky

int main()
{
	int mesiac;
	
	for (mesiac = 1; mesiac <= 12; mesiac++)	
	{
		printf("Mesiac %-9s ma %2d dni.\n", 
				nazov_mesiaca(mesiac), pocet_dni(mesiac));	
	}	
			
	return 0;
}

#include <stdio.h>

//vyuzijeme pole:

//PRE: 1 <= m && m <= 12

char* nazov_mesiaca(int m)

{

char* mena[] = {"januar","februar","marec","april","maj","jun",

"jul","august","september","oktober","november","december"};

return mena[m-1];

}

//vyuzijeme pole:

//PRE: 1 <= m && m <= 12

int pocet_dni(int m)

{

int pocty[] = {31,28,31,30,31,30,31,31,30,31,30,31};

return pocty[m-1];

}

//TODO:

// lokalne, globalne pole, staticke pole

// pole zadanej dlzky, pole premennej dlzky

int main()

{

int mesiac;

for (mesiac = 1; mesiac <= 12; mesiac++)

{

printf("Mesiac %-9s ma %2d dni.\n",

nazov_mesiaca(mesiac), pocet_dni(mesiac));

}

return 0;

}

#define MAXDLZKA  70

int main()
{
	int pole[MAXDLZKA];  //deklaracia prazdneho pola
	int i;
	int dlzka;
	
	//priklad: naplnenie pola
	for (i = 0; i < MAXDLZKA; i++)
	{
		scanf("%d", &pole[i]);
		if (pole[i] == 0)
			break;
	}
	dlzka = i;
	//priklad: vypis pola
	//TODO: pouzite MAXDLZKA namiesto dlzka
	for (i = 0; i < dlzka; i++)
	{
		printf("%i\n", pole[i]);
	}
	
	return 0;
}

#define MAXDLZKA 70

int main()

{

int pole[MAXDLZKA]; //deklaracia prazdneho pola

int i;

int dlzka;

//priklad: naplnenie pola

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

{

scanf("%d", &pole[i]);

if (pole[i] == 0)

break;

}

dlzka = i;

//priklad: vypis pola

//TODO: pouzite MAXDLZKA namiesto dlzka

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

{

printf("%i\n", pole[i]);

}

return 0;

}

#define MAX 500

//priklad globalneho pola
int pole[MAX];

//funkcia na vypis pola, vypise z neho "dlzka" prvkov
void print_pole(int p[], int dlzka)
{
	int i;
	for (i = 0; i < dlzka; i++)
		printf("%i\n", p[i]);
}
//funkcia naplni pole postupnostou cisel 
void napln(int p[], int dlzka)
{
	int i;
	for (i = 0; i < dlzka; i++)
		p[i] = i+1;
}

int main()
{
	int pole2[] = {2,3,5,7,11,13,17,19};
	int dlzka = 5;
	
	//pouzitie funkcie s lokalnym polom
	//pozn.: nastava pretecenie, 
	//  v poli je realne menej ako 10 prvkov
	//  ale funkcia to nema ako zistit 
	print_pole(pole, 10);
	
	printf("-------------------\n");
	
	//pouzitie s globalnym polom
	napln(pole,dlzka);
	print_pole(pole, dlzka);
	
	
	return 0;
}

#define MAX 500

//priklad globalneho pola

int pole[MAX];

//funkcia na vypis pola, vypise z neho "dlzka" prvkov

void print_pole(int p[], int dlzka)

{

int i;

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

printf("%i\n", p[i]);

}

//funkcia naplni pole postupnostou cisel

void napln(int p[], int dlzka)

{

int i;

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

p[i] = i+1;

}

int main()

{

int pole2[] = {2,3,5,7,11,13,17,19};

int dlzka = 5;

//pouzitie funkcie s lokalnym polom

//pozn.: nastava pretecenie,

// v poli je realne menej ako 10 prvkov

// ale funkcia to nema ako zistit

print_pole(pole, 10);

printf("-------------------\n");

//pouzitie s globalnym polom

napln(pole,dlzka);

print_pole(pole, dlzka);

return 0;

}

#include <stdio.h>
#include <time.h>

#define MAXN   10000000

int isprime(int n)
{
	int i;
	for (i = 2; i < n; i++)
		if (n % i == 0)
			return 0;
	return n > 1;
}

int primes(int pole[], int n)
{
	int x, prvyvolny;
	prvyvolny = 0;
	for (x = 2; x < n; x++)
	{
		if (isprime(x))
		{
			pole[prvyvolny] = x;
			prvyvolny++;
		}
	}
	return prvyvolny;
}

int sieve(int pole[], int n)
{
	int i, j;
	//init
	pole[0] = 0;
	pole[1] = 0;
	for (i = 2; i < n; i++)
	{
		pole[i] = i;
	}
	//sieve
	for (j = 2; j < n; j++)
	{
		if (pole[j] == 0)
			continue;
		
		for (i = j + j; i < n; i += j)
			pole[i] = 0;
	}
	//collect
	j = 0;
	for (i = 0; i < n; i++)
	{
		if (pole[i] != 0)
		{
			pole[j] = pole[i];
			j++;
		}
	}
	return j;	
}

int pole[MAXN];

int main1()
{
	int count;
	clock_t start, end;
	start = clock();
	count = sieve(pole, MAXN);
	end = clock();
	//print_pole(pole, count);
	printf("Delta t=%lf s\n", (end-start)/(double)CLOCKS_PER_SEC);
	return 0;
}

void export(int pole[], int n)
{
	int i;
	printf("const int NPRIMES = %i;\n\n",n);
	printf("int g_primes[] = {\n");
	for (i = 0; i < n; i++)
		printf("%i,\n", pole[i]);
	printf("};\n");
}
int main()
{
	int count;
	count = sieve(globalnepole, MAXN);
	export(globalnepole, count);
	return 0;
}

#include <stdio.h>

#include <time.h>

#define MAXN 10000000

int isprime(int n)

{

int i;

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

if (n % i == 0)

return 0;

return n > 1;

}

int primes(int pole[], int n)

{

int x, prvyvolny;

prvyvolny = 0;

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

{

if (isprime(x))

{

pole[prvyvolny] = x;

prvyvolny++;

}

return prvyvolny;

}

int sieve(int pole[], int n)

{

int i, j;

//init

pole[0] = 0;

pole[1] = 0;

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

{

pole[i] = i;

}

//sieve

for (j = 2; j < n; j++)

{

if (pole[j] == 0)

continue;

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

pole[i] = 0;

}

//collect

j = 0;

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

{

if (pole[i] != 0)

{

pole[j] = pole[i];

j++;

}

return j;

}

int pole[MAXN];

int main1()

{

int count;

clock_t start, end;

start = clock();

count = sieve(pole, MAXN);

end = clock();

//print_pole(pole, count);

printf("Delta t=%lf s\n", (end-start)/(double)CLOCKS_PER_SEC);

return 0;

}

void export(int pole[], int n)

{

int i;

printf("const int NPRIMES = %i;\n\n",n);

printf("int g_primes[] = {\n");

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

printf("%i,\n", pole[i]);

printf("};\n");

}

int main()

{

int count;

count = sieve(globalnepole, MAXN);

export(globalnepole, count);

return 0;

}

def isprime(n):
  if n < 2:
    return False
  for x in range(2,n-1):
    if n % x == 0:
      return False
  return True

def primes(n):
  return [x for x in range(n) if isprime(x)]

def primes_e(n):
  lst = list(range(n))
  lst[1] = 0
  for i in range(n):
    x = lst[i]
    if x != 0:
      for j in range(i+x, n, x):
        lst[j] = 0
  return [x for x in lst if x != 0]	

import time

start = time.time()
l1 = primes(30000)
end = time.time()
print(end - start)

start = time.time()
l2 = primes_e(3000000)
end = time.time()
print(end - start)

print(set(l2)==set(l1))

def isprime(n):

if n < 2:

return False

for x in range(2,n-1):

if n % x == 0:

return False

return True

def primes(n):

return [x for x in range(n) if isprime(x)]

def primes_e(n):

lst = list(range(n))

lst[1] = 0

for i in range(n):

x = lst[i]

if x != 0:

for j in range(i+x, n, x):

lst[j] = 0

return [x for x in lst if x != 0]

import time

start = time.time()

l1 = primes(30000)

end = time.time()

print(end - start)

start = time.time()

l2 = primes_e(3000000)

end = time.time()

print(end - start)

print(set(l2)==set(l1))

Príklad swap

#include <stdio.h>

void swap(int *px, int *py)
{
	int tmp;
	
	printf("swap: x = %i, y=%i\n"  ,px , py);
	
	tmp = *px;
	*px = *py;
	*py = tmp;
	
	printf("swap: x = %i, y=%i\n"  ,px , py);
}

void getnewpos(double*px, double *py, double v, int angle)
{
	*px = *px + v * angle;
	if (py != NULL)
	{
		*py = *py - v * angle;
	}
}

int main()
{
	int x = 5, y = 3;
	double a = 0,b = 0;
	
	getnewpos(&a, NULL, 55.4, 34);
	
	printf("main: x = %i, y=%i\n"  ,x , y);
	
	swap(&x, &y);
	
	printf("main: x = %i, y=%i\n"  ,x , y);
	
	return 0;
}

#include <stdio.h>

void swap(int *px, int *py)

{

int tmp;

printf("swap: x = %i, y=%i\n" ,px , py);

tmp = *px;

*px = *py;

*py = tmp;

printf("swap: x = %i, y=%i\n" ,px , py);

}

void getnewpos(double*px, double *py, double v, int angle)

{

*px = *px + v * angle;

if (py != NULL)

{

*py = *py - v * angle;

}

int main()

{

int x = 5, y = 3;

double a = 0,b = 0;

getnewpos(&a, NULL, 55.4, 34);

printf("main: x = %i, y=%i\n" ,x , y);

swap(&x, &y);

printf("main: x = %i, y=%i\n" ,x , y);

return 0;

}

#include <stdio.h>
#include <string.h>


//funkcia najde prvy vyskyt prvku v poli (pole int-ov, smerniky)
int* find_first_int(int *pole, int n, int x) //int*  : funkcia vracia adresu
{
	int i;
	for (i = 0; i < n; i++)
	{
		if (pole[i] == x)
		{
			return &pole[i];  //adresa najdeneho prvku
		}
	}
	
	return NULL;  //specialna adresa (neplatna)
}

//funkcia najde prvy vyskyt prvku v poli (pole int-ov, polia, bez smernikov)
int find_first_index(int pole[], int n, int x)
{
	int i;
	for (i = 0; i < n; i++)
	{
		if (pole[i] == x)
		{
			return i;   //index prvku x
		}
	}
	
	return -1;  //specialny neplatny index
}


//funkcia najde prvy vyskyt prvku v poli (vseobecne, so smernikom na fn)
void* find_first(void *pole, int size_pole,   //kde sa hlada 
                 void *x, int size_x,         //co sa hlada
                 int (*compare)(void*, void*, int) )  //ako sa porovnava
{
	char *ptr, *end;   //ptr: pozicia aktualna, end: za koncom pola
	end = pole + size_pole;
    //preco char* ?  -> aby som sa pohyboval po jednotlivych bajtoch pamate

	// aktualna pozicia sa hybe o size_x, kym neprekroci hranice
	for (ptr = (char*)pole; ptr + size_x <= end; ptr += size_x)
	{
		//volame poskytnutu funkciu na porovnanie
		if (compare(ptr, x, size_x) == 0)
			return ptr;		
	}
	
	return NULL;
}

//porovname obsah pamate ako int-y
int cmp_int(void* a, void* b, int size)
{
	return *((int*) a)   -   *((int*) b);    
}

//porovname obsah pamate ako dva int-y
int cmp_ints(void* a, void* b, int size)
{
	int a1 = ((int*)a)[0], a2 = ((int*)a)[1];  //pretypujeme smernik, pouzijeme ako pole    
	int b1 = ((int*)b)[0], b2 = ((int*)b)[1];    
	int d1 = a1 - b1, d2 = a2 - b2;
	if (d1 != 0)
		return d1;
	return d2;
}


int main1()
{
	int pole[] = {1,2,3,4,5,1,2,3,4,5,6,1,2,3,4,6,7,8};
	int p, odkial, n;
	int x = 3;
	
	odkial = 0;
	n = sizeof(pole)/sizeof(pole[0]);
	p = 0;
	while (p != -1)
	{
		//p = find_first(odkial, koniec-odkial, 3);
		p = find_first_index(pole + odkial, n-odkial, 3 );
		//p je index od zaciatku pola vo funkcii find_first_index
		// realny index je vypocitany: pole[odkial+p] == (pole+odkial)[p] == *(pole+odkial+p)
		
		if (p != -1)
		{
			printf("index: %i\n", p);
			printf("pole[%i] = %i\n", p, pole[p]);
			printf("pole[%i+%i] = %i\n", odkial, p, (pole+odkial)[p]);
		}
		odkial = odkial+p+1;
	}
	
	return 0;
}


int main2()
{
	int pole[] = {1,2,3,4,5,1,2,3,4,5,6,1,2,3,4,6,7,8};
	int* p;
	int* odkial;
	int* koniec;
	int x = 3;
	
	odkial = pole;
	koniec = pole + sizeof(pole)/sizeof(pole[0]);
	p = pole;
	while (p != NULL)
	{
		p = find_first_int(odkial, koniec-odkial, 3);
		
		printf("p=%p\n", p);
		if (p != NULL)
		{
			printf("*p = %i\n", *p);
			printf("index: %i\n", p - pole);
		}
		odkial = p+1;
	}
	
	return 0;
}


int main3()
{
	int pole[] = {1,2,3,4,5,1,2,3,4,5,6,1,2,3,4,6,7,8};
	int* p;
	int* odkial;
	int* koniec;
	int x[] = {3,4};
	
	odkial = pole;
	koniec = pole + sizeof(pole)/sizeof(pole[0]);
	p = pole;
	while (p != NULL)
	{
		p = find_first(odkial, (koniec-odkial) * sizeof(pole[0]), 
		                &x, sizeof(x),
		          cmp_ints );  //najdeme podpostupnost dvoch intov

		//p = find_first(odkial, (koniec-odkial) * sizeof(pole[0]), 
		//                &x[0], sizeof(x[0]),
		//          cmp_int );  //najdeme konkretny int
		
		printf("p=%p\n", p);
		if (p != NULL)
		{
			printf("*p = %i\n", *p);
			printf("*(p+1) = %i\n", *(p+1));
			printf("index: %i\n", p - pole);
		}
		odkial = p+1;
	}
	
	return 0;
}

int main()
{
	main1();
	main2();
	main3();
}

//docasne pole variabilnej dlzky
int test(const int p[], int n)
{
	int pole[n];
	//vyuzitie standardnej kniznice na kopirovanie pamate
	memcpy(pole, p, n * sizeof(int));
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

#include <stdio.h>

#include <string.h>

//funkcia najde prvy vyskyt prvku v poli (pole int-ov, smerniky)

int* find_first_int(int *pole, int n, int x) //int* : funkcia vracia adresu

{

int i;

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

{

if (pole[i] == x)

{

return &pole[i]; //adresa najdeneho prvku

}

return NULL; //specialna adresa (neplatna)

}

//funkcia najde prvy vyskyt prvku v poli (pole int-ov, polia, bez smernikov)

int find_first_index(int pole[], int n, int x)

{

int i;

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

{

if (pole[i] == x)

{

return i; //index prvku x

}

return -1; //specialny neplatny index

}

//funkcia najde prvy vyskyt prvku v poli (vseobecne, so smernikom na fn)

void* find_first(void *pole, int size_pole, //kde sa hlada

void *x, int size_x, //co sa hlada

int (*compare)(void*, void*, int) ) //ako sa porovnava

{

char *ptr, *end; //ptr: pozicia aktualna, end: za koncom pola

end = pole + size_pole;

//preco char* ? -> aby som sa pohyboval po jednotlivych bajtoch pamate

// aktualna pozicia sa hybe o size_x, kym neprekroci hranice

for (ptr = (char*)pole; ptr + size_x <= end; ptr += size_x)

{

//volame poskytnutu funkciu na porovnanie

if (compare(ptr, x, size_x) == 0)

return ptr;

}

return NULL;

}

//porovname obsah pamate ako int-y

int cmp_int(void* a, void* b, int size)

{

return *((int*) a) - *((int*) b);

}

//porovname obsah pamate ako dva int-y

int cmp_ints(void* a, void* b, int size)

{

int a1 = ((int*)a)[0], a2 = ((int*)a)[1]; //pretypujeme smernik, pouzijeme ako pole

int b1 = ((int*)b)[0], b2 = ((int*)b)[1];

int d1 = a1 - b1, d2 = a2 - b2;

if (d1 != 0)

return d1;

return d2;

}

int main1()

{

int pole[] = {1,2,3,4,5,1,2,3,4,5,6,1,2,3,4,6,7,8};

int p, odkial, n;

int x = 3;

odkial = 0;

n = sizeof(pole)/sizeof(pole[0]);

p = 0;

while (p != -1)

{

//p = find_first(odkial, koniec-odkial, 3);

p = find_first_index(pole + odkial, n-odkial, 3 );

//p je index od zaciatku pola vo funkcii find_first_index

// realny index je vypocitany: pole[odkial+p] == (pole+odkial)[p] == *(pole+odkial+p)

if (p != -1)

{

printf("index: %i\n", p);

printf("pole[%i] = %i\n", p, pole[p]);

printf("pole[%i+%i] = %i\n", odkial, p, (pole+odkial)[p]);

}

odkial = odkial+p+1;

}

return 0;

}

int main2()

{

int pole[] = {1,2,3,4,5,1,2,3,4,5,6,1,2,3,4,6,7,8};

int* p;

int* odkial;

int* koniec;

int x = 3;

odkial = pole;

koniec = pole + sizeof(pole)/sizeof(pole[0]);

p = pole;

while (p != NULL)

{

p = find_first_int(odkial, koniec-odkial, 3);

printf("p=%p\n", p);

if (p != NULL)

{

printf("*p = %i\n", *p);

printf("index: %i\n", p - pole);

}

odkial = p+1;

}

return 0;

}

int main3()

{

int pole[] = {1,2,3,4,5,1,2,3,4,5,6,1,2,3,4,6,7,8};

int* p;

int* odkial;

int* koniec;

int x[] = {3,4};

odkial = pole;

koniec = pole + sizeof(pole)/sizeof(pole[0]);

p = pole;

while (p != NULL)

{

p = find_first(odkial, (koniec-odkial) * sizeof(pole[0]),

&x, sizeof(x),

cmp_ints ); //najdeme podpostupnost dvoch intov

//p = find_first(odkial, (koniec-odkial) * sizeof(pole[0]),

// &x[0], sizeof(x[0]),

// cmp_int ); //najdeme konkretny int

printf("p=%p\n", p);

if (p != NULL)

{

printf("*p = %i\n", *p);

printf("*(p+1) = %i\n", *(p+1));

printf("index: %i\n", p - pole);

}

odkial = p+1;

}

return 0;

}

int main()

{

main1();

main2();

main3();

}

//docasne pole variabilnej dlzky

int test(const int p[], int n)

{

int pole[n];

//vyuzitie standardnej kniznice na kopirovanie pamate

memcpy(pole, p, n * sizeof(int));

}

Príklad na triedenie poľa štruktúr

#include <stdio.h>
#include <time.h>
#include <stdlib.h>

typedef struct _tag
{
	double lat, lon;
} Location;

typedef double celzius_t;

typedef struct
{
	int id_agent;
	Location location;
	time_t timestamp;
	celzius_t temperature;   // in degree Celsius
} Record;

#define DBSIZE 100
Record DataBase[DBSIZE];

#define NUM_AGENTS 10

Location random_location()
{
	static Location location = {0,0};
	
	location.lat += (rand() / (double)RAND_MAX) * (2) - 1;
	location.lon += (rand() / (double)RAND_MAX) * (2) - 1;
	
	return location;
}

Record random_record()
{
	Record record;
	
	record.id_agent = rand() % NUM_AGENTS;
	record.location = random_location();
	record.temperature = (rand() / (double)RAND_MAX) * (60) - 20;
	record.timestamp = time(0) + rand();
	
	return record;
}

void init(Record db[], int size)
{
	int i;
	for (i = 0; i < size; i++)
		db[i] = random_record();
}

void print_record(Record record)
{
	printf("AGENT%02i:\n", record.id_agent );
	printf(" Loc: %3.6lf, %3.6lf\n", record.location.lat, record.location.lon);
	printf(" Temperature: %2.2lf C\n", record.temperature);
	printf(" Time: %s\n", asctime(gmtime(&record.timestamp)) );
}


void print(Record db[], int size)
{
	int i;
	for (i = 0; i < size; i++)
		print_record(db[i]);
}

void print_indirect(Record* index[], int size)
{
	int i;
	for (i = 0; i < size; i++)
		print_record( *(index[i])  );
}

int cmp_record_by_id(const void *a, const void *b)
{
	Record *r1 = (Record*) a;
	Record *r2 = (Record*) b;
	return r1->id_agent - r2->id_agent;
}

void sort_by_id(Record db[], int size)
{
	qsort(db, size, sizeof(Record), cmp_record_by_id);
}

int cmp_record_by_time(const void *a, const void *b)
{
	Record *r1 = (Record*) a;
	Record *r2 = (Record*) b;
	return difftime(r1->timestamp, r2->timestamp);
}

void sort_by_time(Record db[], int size)
{
	qsort(db, size, sizeof(Record), cmp_record_by_time);
}

int cmp_record_by_time_indirect(const void *a, const void *b)
{
	Record **r1 = (Record**) a;
	Record **r2 = (Record**) b;
	return difftime((*r1)->timestamp, (*r2)->timestamp);
}

void index_by_time(Record db[], int size, Record* index[])
{
	int i;
	for (i = 0; i < size; i++)
		index[i] = &db[i];
	
	qsort(index, size, sizeof(Record*), cmp_record_by_time_indirect);
}

int main()
{
	srand(time(0));
	Record* index_time[DBSIZE];
	
	init(DataBase, DBSIZE);
	
	
//	sort_by_id(DataBase, DBSIZE);
//	print(DataBase, 10);
//	system("pause");

	index_by_time(DataBase, DBSIZE, index_time);
	print(DataBase, 10);
	system("pause");
	print_indirect(index_time, 10);
	
	return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

#include <stdio.h>

#include <time.h>

#include <stdlib.h>

typedef struct _tag

{

double lat, lon;

} Location;

typedef double celzius_t;

typedef struct

{

int id_agent;

Location location;

time_t timestamp;

celzius_t temperature; // in degree Celsius

} Record;

#define DBSIZE 100

Record DataBase[DBSIZE];

#define NUM_AGENTS 10

Location random_location()

{

static Location location = {0,0};

location.lat += (rand() / (double)RAND_MAX) * (2) - 1;

location.lon += (rand() / (double)RAND_MAX) * (2) - 1;

return location;

}

Record random_record()

{

Record record;

record.id_agent = rand() % NUM_AGENTS;

record.location = random_location();

record.temperature = (rand() / (double)RAND_MAX) * (60) - 20;

record.timestamp = time(0) + rand();

return record;

}

void init(Record db[], int size)

{

int i;

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

db[i] = random_record();

}

void print_record(Record record)

{

printf("AGENT%02i:\n", record.id_agent );

printf(" Loc: %3.6lf, %3.6lf\n", record.location.lat, record.location.lon);

printf(" Temperature: %2.2lf C\n", record.temperature);

printf(" Time: %s\n", asctime(gmtime(&record.timestamp)) );

}

void print(Record db[], int size)

{

int i;

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

print_record(db[i]);

}

void print_indirect(Record* index[], int size)

{

int i;

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

print_record( *(index[i]) );

}

int cmp_record_by_id(const void *a, const void *b)

{

Record *r1 = (Record*) a;

Record *r2 = (Record*) b;

return r1->id_agent - r2->id_agent;

}

void sort_by_id(Record db[], int size)

{

qsort(db, size, sizeof(Record), cmp_record_by_id);

}

int cmp_record_by_time(const void *a, const void *b)

{

Record *r1 = (Record*) a;

Record *r2 = (Record*) b;

return difftime(r1->timestamp, r2->timestamp);

}

void sort_by_time(Record db[], int size)

{

qsort(db, size, sizeof(Record), cmp_record_by_time);

}

int cmp_record_by_time_indirect(const void *a, const void *b)

{

Record **r1 = (Record**) a;

Record **r2 = (Record**) b;

return difftime((*r1)->timestamp, (*r2)->timestamp);

}

void index_by_time(Record db[], int size, Record* index[])

{

int i;

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

index[i] = &db[i];

qsort(index, size, sizeof(Record*), cmp_record_by_time_indirect);

}

int main()

{

srand(time(0));

Record* index_time[DBSIZE];

init(DataBase, DBSIZE);

// sort_by_id(DataBase, DBSIZE);

// print(DataBase, 10);

// system("pause");

index_by_time(DataBase, DBSIZE, index_time);

print(DataBase, 10);

system("pause");

print_indirect(index_time, 10);

return 0;

}

Znaky

#include <stdio.h>
#include <ctype.h>

//funkcia po vzore "ctype.h"
int je_samohlaska(int c)
{
	switch (tolower(c))
	{
		case 'a':
		case 'e':
		case 'i':
		case 'o':
		case 'u':
		case 'y':
			return 1;
		default:
			return 0;
	}
	return 0;
}

//funkcia na vypis postupnosti bajtov z pamate, zadana je dlzka
void print_mem(unsigned char * p, int len)
{
	int i;
	for (i = 0; i < len; i++)
		printf("%02x: %c\n", p[i], *(p+i));
}

//ako predosle, ale nie je znama dlzka, iba ukoncenie 0
void print_mem2(unsigned char * p)
{
	while (*p != 0)
	{
		printf("%02x: %c\n", *p, *p);
		p++;
	}
}

int main()
{
	int a, b, c = 0x54534554;
	
	//dve deklaracie toho isteho pola znakov
//	char pole[] = {'t', 'e', 's', 't', '\0'};
	char pole[] = "test";
	//retazec: pole znakov ukoncene 0  (v znakovom zapise '\0')
	
	char *p = pole;
	//a = 'a'; b = 2;
	//c = a+b;
	
	print_mem(&c, sizeof(int));		
	print_mem2(&c);		

	print_mem(pole, sizof(pole));		
	print_mem2(pole);		
	
	return 0;
}

#include <stdio.h>

#include <ctype.h>

//funkcia po vzore "ctype.h"

int je_samohlaska(int c)

{

switch (tolower(c))

{

case 'a':

case 'e':

case 'i':

case 'o':

case 'u':

case 'y':

return 1;

default:

return 0;

}

return 0;

}

//funkcia na vypis postupnosti bajtov z pamate, zadana je dlzka

void print_mem(unsigned char * p, int len)

{

int i;

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

printf("%02x: %c\n", p[i], *(p+i));

}

//ako predosle, ale nie je znama dlzka, iba ukoncenie 0

void print_mem2(unsigned char * p)

{

while (*p != 0)

{

printf("%02x: %c\n", *p, *p);

p++;

}

int main()

{

int a, b, c = 0x54534554;

//dve deklaracie toho isteho pola znakov

// char pole[] = {'t', 'e', 's', 't', '\0'};

char pole[] = "test";

//retazec: pole znakov ukoncene 0 (v znakovom zapise '\0')

char *p = pole;

//a = 'a'; b = 2;

//c = a+b;

print_mem(&c, sizeof(int));

print_mem2(&c);

print_mem(pole, sizof(pole));

print_mem2(pole);

return 0;

}

Reťazce

#include <stdio.h>

//PRE: minimalne mat miesto na 27 znakov...
void abeceda(char pole[])
{
	int i;
	
	for (i = 0; i < 26; i++)
		pole[i] = 'a'+i;   //naplnime pole abecedou
	pole[26] = '\0';	   // a pridame ukoncovaci znak
}

int main()
{
	//rozne retazce:
	// smernik ukazujuci do pamate skompilovaneho programu
	char *str1 = "abcdefghijklmnopqrstuvwxyz";
	
	//lokalne pole inicializovane znakmi
	char str2[] = "abcdefghijklmnopqrstuvwxyz";
	
	//dalsie lokalne pole
	char pole[100] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxx";

    //aj ked maju rovnaky obsah, tu sa porovnavaju adresy...	
	printf("Zhoda: %i\n", str1==str2);
	//vsimnite si rozne velkosti
	printf("sizeof(str1) = %i\n", sizeof(str1));  //smernik
	printf("sizeof(str2) = %i\n", sizeof(str2));  //pole

	
	//priklad nacitania riadku zo vstupu
	fgets(pole, 100, stdin);

	//priklad nacitania slova zo vstupu
	scanf("%10s", pole);
	
	//priklad naplnenia pola funkciou
	abeceda(pole);
	
	//priklad vypisu retazca: je jedno, ako bol ziskany
	printf("str1 = %s\n", str1);
	printf("str2 = %s\n", str2);
	printf("pole = %s\n", pole);
	
	//v jednom poli moze byt ulozenych viac retazcov...
	printf("pole+27 = %s\n", pole+27);
	
	return 0;
}

#include <stdio.h>

//PRE: minimalne mat miesto na 27 znakov...

void abeceda(char pole[])

{

int i;

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

pole[i] = 'a'+i; //naplnime pole abecedou

pole[26] = '\0'; // a pridame ukoncovaci znak

}

int main()

{

//rozne retazce:

// smernik ukazujuci do pamate skompilovaneho programu

char *str1 = "abcdefghijklmnopqrstuvwxyz";

//lokalne pole inicializovane znakmi

char str2[] = "abcdefghijklmnopqrstuvwxyz";

//dalsie lokalne pole

char pole[100] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxxxx";

//aj ked maju rovnaky obsah, tu sa porovnavaju adresy...

printf("Zhoda: %i\n", str1==str2);

//vsimnite si rozne velkosti

printf("sizeof(str1) = %i\n", sizeof(str1)); //smernik

printf("sizeof(str2) = %i\n", sizeof(str2)); //pole

//priklad nacitania riadku zo vstupu

fgets(pole, 100, stdin);

//priklad nacitania slova zo vstupu

scanf("%10s", pole);

//priklad naplnenia pola funkciou

abeceda(pole);

//priklad vypisu retazca: je jedno, ako bol ziskany

printf("str1 = %s\n", str1);

printf("str2 = %s\n", str2);

printf("pole = %s\n", pole);

//v jednom poli moze byt ulozenych viac retazcov...

printf("pole+27 = %s\n", pole+27);

return 0;

}

Príklady z cvičenia

#include <stdio.h>

//vypis vsetkych argumentov programu:
int main(int argc, char* argv[])
{
	int i;
	for (i = 0; i < argc; i++)
	{
		printf("%i: %s\n", i, argv[i]);
	}

	return 0;
}

#include <stdio.h>

//vypis vsetkych argumentov programu:

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

{

int i;

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

{

printf("%i: %s\n", i, argv[i]);

}

return 0;

}

#include <stdio.h>

//priklad: vyuzitie funkcie sprintf/sscanf
int main(int argc, char* argv[])
{
	//6 znakov na extra pismena, 10 znakov na cislo
	int kapacita = 6 + 10 + strlen(argv[1]) + strlen(argv[2]);
	char buffer[kapacita];
	int x;
	
	sprintf(buffer, "%i: %s - %s", kapacita, argv[1], argv[2]);

	printf("Vzniklo: %s\n", buffer);
	
	sscanf(argv[1], "%i", &x);
	printf("2x= %i\n", 2*x);


	return 0;
}

#include <stdio.h>

//priklad: vyuzitie funkcie sprintf/sscanf

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

{

//6 znakov na extra pismena, 10 znakov na cislo

int kapacita = 6 + 10 + strlen(argv[1]) + strlen(argv[2]);

char buffer[kapacita];

int x;

sprintf(buffer, "%i: %s - %s", kapacita, argv[1], argv[2]);

printf("Vzniklo: %s\n", buffer);

sscanf(argv[1], "%i", &x);

printf("2x= %i\n", 2*x);

return 0;

}

#include <stdio.h>

//realizacia porovnania retazcov, case insensitive
int compare(char * s1, char * s2)
{
	while (toupper(*s1) == toupper(*s2) && *s1 != '\0')
	{
		s1++; s2++;
	}
	return toupper(*s1) - toupper(*s2);
}

//testovaci kod
int main(int argc, char* argv[])
{
	//na regularne porovnanie sa da vyuzit strcmp
	if (compare(argv[1], argv[2]) == 0)
	{
		printf("Zhoda\n");
	}
	else
	{
		printf("Nezhoda\n");
	}

	return 0;
}

#include <stdio.h>

//realizacia porovnania retazcov, case insensitive

int compare(char * s1, char * s2)

{

while (toupper(*s1) == toupper(*s2) && *s1 != '\0')

{

s1++; s2++;

}

return toupper(*s1) - toupper(*s2);

}

//testovaci kod

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

{

//na regularne porovnanie sa da vyuzit strcmp

if (compare(argv[1], argv[2]) == 0)

{

printf("Zhoda\n");

}

else

{

printf("Nezhoda\n");

}

return 0;

}

#include <stdio.h>
#include <string.h>

//funkcia, ktora vlozi jeden retazec do druheho
// po vzore strcat
char* insert(char* to, char* what, int where)
{
	if (where < 0)
		where = 0;
	if (where > strlen(to))
		where = strlen(to);
	
	memmove(to+where+strlen(what), to+where, strlen(to)-where+1);
	memmove(to+where, what, strlen(what));
	return to;
}

//testovaci kod
int main(int argc, char* argv[])
{
	char * s1 = argv[1];
	char * s2 = argv[2];
	int ix = atoi (argv[3]);
	//musime mat rezervovanu dostatocnu pamat
	char buffer[strlen(s1)+strlen(s2)+1];
	
	//vyuzijeme strcpy na inicializaciu buffera
	strcpy(buffer, s1);
	insert(buffer, s2, ix);
	printf("%s\n", buffer);

	return 0;
}

#include <stdio.h>

#include <string.h>

//funkcia, ktora vlozi jeden retazec do druheho

// po vzore strcat

char* insert(char* to, char* what, int where)

{

if (where < 0)

where = 0;

if (where > strlen(to))

where = strlen(to);

memmove(to+where+strlen(what), to+where, strlen(to)-where+1);

memmove(to+where, what, strlen(what));

return to;

}

//testovaci kod

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

{

char * s1 = argv[1];

char * s2 = argv[2];

int ix = atoi (argv[3]);

//musime mat rezervovanu dostatocnu pamat

char buffer[strlen(s1)+strlen(s2)+1];

//vyuzijeme strcpy na inicializaciu buffera

strcpy(buffer, s1);

insert(buffer, s2, ix);

printf("%s\n", buffer);

return 0;

}

Príklad na prácu so súbormi

/*
Program archivuje subory

archive.exe ARCHIV [zoznam suborov]
extract.exe ARCHIV

Datovy format:
MENO SUBORU
DLZKA
DATA
MENO SUBORU
DLZKA
DATA
 */

#include <stdio.h>
#define ERR_OPEN -1
#define OK        0

int copy(FILE* out, FILE* in)
{
	int c;
	int count = 0;
	while ( (c = fgetc(in)) != EOF )
	{
		fputc(c, out);
		count++;
	}
	return count;
}

int archive_file(FILE *out, char* filename)
{
	FILE *input;
	int len;
	long pos;
	
	input = fopen(filename, "rb");
	if (input == NULL)
		return ERR_OPEN;
	
	fprintf(out, "%s\n", filename);
	
	pos = ftell(out);
	fwrite(&len, sizeof(len), 1, out);
	
	len = copy(out, input);
	
	fseek(out, pos, SEEK_SET);
	fwrite(&len, sizeof(len), 1, out);
	fseek(out, 0, SEEK_END);
	
	return OK;
}

int archive(const char* archivename, int num, char* list[])
{
	FILE *out;
	int i, ok = OK;
	
	out = fopen(archivename, "wb");
	if (out == NULL)
		return ERR_OPEN;
		
	for (i = 0; i < num; i++)
	{
		if (archive_file(out, list[i]) == ERR_OPEN)
		{
			ok = ERR_OPEN;
			break;
		}
	}
	
	fclose(out);
	return ok;
}

int main(int argc, char* argv[])
{
	if (argc <= 2)
		return -1;
		
	archive(argv[1],argc-2, argv+2);
	
	
	return 0;
}

Program archivuje subory

archive.exe ARCHIV [zoznam suborov]

extract.exe ARCHIV

Datovy format:

MENO SUBORU

DLZKA

DATA

MENO SUBORU

DLZKA

DATA

#include <stdio.h>

#define ERR_OPEN -1

#define OK 0

int copy(FILE* out, FILE* in)

{

int c;

int count = 0;

while ( (c = fgetc(in)) != EOF )

{

fputc(c, out);

count++;

}

return count;

}

int archive_file(FILE *out, char* filename)

{

FILE *input;

int len;

long pos;

input = fopen(filename, "rb");

if (input == NULL)

return ERR_OPEN;

fprintf(out, "%s\n", filename);

pos = ftell(out);

fwrite(&len, sizeof(len), 1, out);

len = copy(out, input);

fseek(out, pos, SEEK_SET);

fwrite(&len, sizeof(len), 1, out);

fseek(out, 0, SEEK_END);

return OK;

}

int archive(const char* archivename, int num, char* list[])

{

FILE *out;

int i, ok = OK;

out = fopen(archivename, "wb");

if (out == NULL)

return ERR_OPEN;

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

{

if (archive_file(out, list[i]) == ERR_OPEN)

{

ok = ERR_OPEN;

break;

}

fclose(out);

return ok;

}

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

{

if (argc <= 2)

return -1;

archive(argv[1],argc-2, argv+2);

return 0;

}

/*
Program archivuje subory

archive.exe ARCHIV [zoznam suborov]
extract.exe ARCHIV

Datovy format:
MENO SUBORU
DLZKA
DATA
MENO SUBORU
DLZKA
DATA
 */

#include <stdio.h>
#include <string.h>
#define ERR_OPEN -1
#define OK        0

int copy_bytes(FILE* out, FILE* in, int len)
{
	int c;
	while (len > 0)
	{
		c = fgetc(in);
		fputc(c, out);
		len--;
	}

	return len;
}

int extract_file(FILE *in, char* filename, int len)
{
	FILE *output;

	output = fopen(filename, "wb");
	if (output == NULL)
		return ERR_OPEN;
	
	copy_bytes(output, in, len);
	fclose(output);
	return OK;
}
#define MAXFILENAME 10000
int extract(const char* archivename)
{
	FILE *in;
	int i, len, ok = OK;
	static char buffer[MAXFILENAME];
	
	in = fopen(archivename, "rb");
	if (in == NULL)
		return ERR_OPEN;
		
	do {
		if (fgets(buffer, MAXFILENAME, in) == NULL)
			break;
		len = strlen(buffer);
		if (len < 1 || len >= MAXFILENAME )
			break;
		buffer[len-1] = '\0';
		
		fread(&len, sizeof(len), 1, in);
		//TODO: verify fread ok...
		
		extract_file(in, buffer, len);
		//TODO: verify extract OK
	} while (1 == 1);
	
	
	fclose(in);
	return ok;
}

int main(int argc, char* argv[])
{
	if (argc <= 1)
		return -1;
		
	extract(argv[1]);
	
	
	return 0;
}

Program archivuje subory

archive.exe ARCHIV [zoznam suborov]

extract.exe ARCHIV

Datovy format:

MENO SUBORU

DLZKA

DATA

MENO SUBORU

DLZKA

DATA

#include <stdio.h>

#include <string.h>

#define ERR_OPEN -1

#define OK 0

int copy_bytes(FILE* out, FILE* in, int len)

{

int c;

while (len > 0)

{

c = fgetc(in);

fputc(c, out);

len--;

}

return len;

}

int extract_file(FILE *in, char* filename, int len)

{

FILE *output;

output = fopen(filename, "wb");

if (output == NULL)

return ERR_OPEN;

copy_bytes(output, in, len);

fclose(output);

return OK;

}

#define MAXFILENAME 10000

int extract(const char* archivename)

{

FILE *in;

int i, len, ok = OK;

static char buffer[MAXFILENAME];

in = fopen(archivename, "rb");

if (in == NULL)

return ERR_OPEN;

do {

if (fgets(buffer, MAXFILENAME, in) == NULL)

break;

len = strlen(buffer);

if (len < 1 || len >= MAXFILENAME )

break;

buffer[len-1] = '\0';

fread(&len, sizeof(len), 1, in);

//TODO: verify fread ok...

extract_file(in, buffer, len);

//TODO: verify extract OK

} while (1 == 1);

fclose(in);

return ok;

}

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

{

if (argc <= 1)

return -1;

extract(argv[1]);

return 0;

}

Dynamická alokácia

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

//Funkcia obrati retazec (nemeni povodny)
const char* reverse(const char* str)
{
	int i, j, len = strlen(str);
	char *pole;
	
	//dynamicka alokacia je jedina vhodna...
	pole = (char*) malloc( (len+1)*sizeof(char) );
	 
	j = 0;
	for (i = len-1; i >= 0; i--)
	{
		pole[j]  = str[i];
		j++;
	}
	pole[j] = '\0';
	
	return pole;
}


int main(int argc, char *argv[])
{
	int i;
	const char *str = "panama";
	const char *new_str = NULL;
	for (i = 0; i >= 0; i++)
	{
		printf("str%04i: %s\n", i, str);
		new_str = reverse(str);
		
		//v cykle spravne uvolnovat pamat 
		// je "mierne problematicke"
		if (i > 0)
			free(str);
		str = new_str;
	}
	
	return 1;
}

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

//Funkcia obrati retazec (nemeni povodny)

const char* reverse(const char* str)

{

int i, j, len = strlen(str);

char *pole;

//dynamicka alokacia je jedina vhodna...

pole = (char*) malloc( (len+1)*sizeof(char) );

j = 0;

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

{

pole[j] = str[i];

j++;

}

pole[j] = '\0';

return pole;

}

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

{

int i;

const char *str = "panama";

const char *new_str = NULL;

for (i = 0; i >= 0; i++)

{

printf("str%04i: %s\n", i, str);

new_str = reverse(str);

//v cykle spravne uvolnovat pamat

// je "mierne problematicke"

if (i > 0)

free(str);

str = new_str;

}

return 1;

}

Načítanie riadkov

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

typedef struct {
	int pocet;
	char** pole;
} Riadky;

const char* reverse(const char* str);

#define MAXCOUNT 100000
char* readline(FILE* f) 
{ 
	static char buffer[MAXCOUNT];
	int len;

	fgets(buffer, MAXCOUNT, f);
	//TODO: osetrit pretecenie
	
	len = strlen(buffer);
	if (len > 0 && buffer[len-1] == '\n')
		buffer[len-1] = '\0';
	//else ... nenacital riadok
	
	return buffer;
}
int append(Riadky* pRiadky, char* riadok)
{
	char * line;
	//zvacsit pamat
	pRiadky->pole = 
		(char**) 	realloc(pRiadky->pole, 
	                    (pRiadky->pocet+1)*sizeof(char*));
		
	line = (char*) malloc(strlen(riadok)+1);
	strcpy(line, riadok);

	pRiadky->pole[pRiadky->pocet] = line;
	pRiadky->pocet++;
	
	return 1;
}

int nacitaj(const char* meno, Riadky* pRiadky)
{
	FILE *f;
	char *riadok;
	//otvor subor
	f = fopen(meno, "r");
	if (f == NULL)
		return 0;
		
	append(pRiadky, "=== Zaciatok suboru ===");
	
	//nacitaj zo suboru kazdy riadok
	while (!feof(f))
	{
		riadok = readline(f);
		append(pRiadky, riadok);
	}

	//zatvor subor
	fclose(f);
	return 1;
}

void vypis(char* riadky[], int pocet)
{
	int i;
	for (i = 0; i < pocet; i++)
		printf("%s\n", riadky[i]);
}

void empty(Riadky* pRiadky)
{
	int i;
	for (i = 0; i < pRiadky->pocet; i++)
	{
		free(pRiadky->pole[i]);
	}
	if (pRiadky->pole != NULL)
		free(pRiadky->pole);
	
	pRiadky->pocet = 0;
	pRiadky->pole  = NULL;
}

int main(int argc, char *argv[])
{
	Riadky riadky = {0,NULL};
	if (argc < 2)
		return -1;
		
	nacitaj(argv[1], &riadky);
	
	if (riadky.pocet > 10)
		vypis(riadky.pole, 10);
	
	empty(&riadky);
	
	return 1;
}

100

101

102

103

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

typedef struct {

int pocet;

char** pole;

} Riadky;

const char* reverse(const char* str);

#define MAXCOUNT 100000

char* readline(FILE* f)

{

static char buffer[MAXCOUNT];

int len;

fgets(buffer, MAXCOUNT, f);

//TODO: osetrit pretecenie

len = strlen(buffer);

if (len > 0 && buffer[len-1] == '\n')

buffer[len-1] = '\0';

//else ... nenacital riadok

return buffer;

}

int append(Riadky* pRiadky, char* riadok)

{

char * line;

//zvacsit pamat

pRiadky->pole =

(char**) realloc(pRiadky->pole,

(pRiadky->pocet+1)*sizeof(char*));

line = (char*) malloc(strlen(riadok)+1);

strcpy(line, riadok);

pRiadky->pole[pRiadky->pocet] = line;

pRiadky->pocet++;

return 1;

}

int nacitaj(const char* meno, Riadky* pRiadky)

{

FILE *f;

char *riadok;

//otvor subor

f = fopen(meno, "r");

if (f == NULL)

return 0;

append(pRiadky, "=== Zaciatok suboru ===");

//nacitaj zo suboru kazdy riadok

while (!feof(f))

{

riadok = readline(f);

append(pRiadky, riadok);

}

//zatvor subor

fclose(f);

return 1;

}

void vypis(char* riadky[], int pocet)

{

int i;

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

printf("%s\n", riadky[i]);

}

void empty(Riadky* pRiadky)

{

int i;

for (i = 0; i < pRiadky->pocet; i++)

{

free(pRiadky->pole[i]);

}

if (pRiadky->pole != NULL)

free(pRiadky->pole);

pRiadky->pocet = 0;

pRiadky->pole = NULL;

}

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

{

Riadky riadky = {0,NULL};

if (argc < 2)

return -1;

nacitaj(argv[1], &riadky);

if (riadky.pocet > 10)

vypis(riadky.pole, 10);

empty(&riadky);

return 1;

}

Dynamická alokácia matice

//alokujte maticu m x n
double** alloc_matrix(int m, int n)
{
	double** matrix;
	double* row;
	int r;
	
	matrix = (double**) calloc(m, sizeof(double*));
	
	for (r = 0; r < m; r++)
	{
		matrix[r] = (double*) calloc(n, sizeof(double));
	}
	for (r = 0; r < min(m,n); r++)
	{
		matrix[r][r] = 1.0;
	}
	return matrix;
}


//alokujte maticu m x n: pokrocila verzia s 1 alokaciou
double** alloc_matrix(int m, int n)
{
	double** matrix;
	double* row;
	int r;
	
	matrix = (double**) malloc(m*sizeof(double*)
								+ m*n*sizeof(double)
							);
	row = (double*)  (&matrix[m]);
	for (r = 0; r < m; r++)
	{
		matrix[r] = row;
		row += n;
	}
	for (r = 0; r < min(m,n); r++)
	{
		matrix[r][r] = 1.0;
	}
	return matrix;
}

//alokujte maticu m x n

double** alloc_matrix(int m, int n)

{

double** matrix;

double* row;

int r;

matrix = (double**) calloc(m, sizeof(double*));

for (r = 0; r < m; r++)

{

matrix[r] = (double*) calloc(n, sizeof(double));

}

for (r = 0; r < min(m,n); r++)

{

matrix[r][r] = 1.0;

}

return matrix;

}

//alokujte maticu m x n: pokrocila verzia s 1 alokaciou

double** alloc_matrix(int m, int n)

{

double** matrix;

double* row;

int r;

matrix = (double**) malloc(m*sizeof(double*)

+ m*n*sizeof(double)

);

row = (double*) (&matrix[m]);

for (r = 0; r < m; r++)

{

matrix[r] = row;

row += n;

}

for (r = 0; r < min(m,n); r++)

{

matrix[r][r] = 1.0;

}

return matrix;

}

Huffman kompresia súborov

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

//  POPIS read_file():
//      Funkcia, ktora precita obsah suboru (fname) 
//      do dynamickeho pola znakov 
//      a vrati pointer na jeho zaciatok + dlzku.
//  IN:
//      fname   - retazec obsahujuci nazov suboru
//      pLen    - pointer, kam sa zapise dlzka suboru
//  OUT:
//      unsigned char* - pointer na binarny obsah suboru
//      

unsigned char* read_file(char* fname, size_t *pLen)
{
	FILE * f;
	size_t len,pos;
	unsigned char* out;
	
	f = fopen(fname, "rb"); // otvarame subor v binarnom rezime
	if (f == NULL) // kontrolujeme, ci otvaranie prebehlo OK
		return NULL;

	pos = ftell(f);    // aktualna pozicia
    fseek(f, 0, SEEK_END);    // presunieme sa na koniec suboru
    len = ftell(f); // zistenie aktualnej pozicie v subore
    fseek(f, pos, SEEK_SET);  // vratenie sa na zaciatok suboru

	out = (unsigned char*)malloc(len); // alokujeme pamat pre retazec + 1 ukoncovaci znak
	if(out == NULL){
        fprintf(stderr, "Alokacia pamate zlyhala.\n");
		exit(-1);        
	}

	// nacitanie suboru do retazca
	fread(out, sizeof(unsigned char), len, f);

	fclose(f); // zavrieme subor
	
	//vratime dlzku a nacitane data
	*pLen = len;  
	return out;
}

int compress(unsigned char *data, size_t *pLen);

int write_file(char* fname, unsigned char *data, size_t len)
{
	FILE *f = fopen(fname, "wb");
	
	if (f == NULL)
		return 0;
		
	fwrite(data, sizeof(unsigned char), len, f);
	fclose(f);
	return 1;
}

int main(int argc, char* argv[])
{
	size_t len, ones;
	unsigned char * data;
	char *fname = "test.bmp";
	
	if (argc >= 2)
		fname = argv[1];
	
	data = read_file(fname, &len);
	if (data != NULL)
	{
		compress(data, &len);
		write_file("huff.out", data, len);	
		free(data);
	}
	return 0;	
}

#define NSYM  256

typedef struct _symbol {
	int code;
	int count;
	struct _symbol *parent;
	struct _symbol *zero, *one;
} Symbol;

char* huffcode(Symbol* pSymbol)
{
	static char str[NSYM + 1] = "";
	int i = NSYM-1;
	while (pSymbol->parent != 0)
	{
		if (pSymbol->parent->zero == pSymbol)
			str[i] = '0';
		else
			str[i] = '1';
		i--;
		pSymbol = pSymbol->parent;
	}
	return &str[i+1];
}

//PRE: symbols len is 2n
int	huffman(Symbol symbols[], int n)
{
	int i, from = 0, to = n;
	Symbol* tmp;
	Symbol* ptrs[2*n];
	
	for (i = 0; i < 2*n; i++)
		ptrs[i] = &symbols[i];
	
	while (to - from > 1)
	{
		//prve dve su minimum
		for (i = from+1; i < to; i++)
		{
			if (ptrs[i]->count < ptrs[from]->count)
			{
				tmp        = ptrs[from];
				ptrs[from] = ptrs[i];
				ptrs[i] = tmp;
			}
			if (ptrs[i]->count < ptrs[from+1]->count)
			{
				tmp        = ptrs[from+1];
				ptrs[from+1] = ptrs[i];
				ptrs[i] = tmp;
			}
		}
		
		//pridaj na koniec novy uzol...
		ptrs[to]->code  = -1;
		ptrs[to]->count = ptrs[from]->count + 
						    ptrs[from+1]->count;
		ptrs[to]->zero  = ptrs[from];
		ptrs[to]->one  = ptrs[from+1];
		ptrs[from]->parent = ptrs[to];
		ptrs[from+1]->parent = ptrs[to];
		
		to++;
		from += 2;
	}
}

int compress(unsigned char *data, size_t *pLen)
{
	Symbol symbols[2*NSYM] = {0};
	Symbol* pRoot;
	unsigned char *tmp;
	char *code;
	int i, j, len = *pLen;

	for (i = 0; i < NSYM; i++)
		symbols[i].code = i;
	
	for (i = 0; i < len; i++)
		symbols[data[i]].count++;
		
	//debug...
	for (i = 0; i < NSYM; i++)
		printf("%i: %i\n", 
			symbols[i].code,
			symbols[i].count);

	//Huffman, jednoducha verzia...
	huffman(symbols, NSYM);
	
	//debug...	
	for (i = 0; i < NSYM; i++)
	{
		printf("%i: %s\n", symbols[i].code, huffcode(&symbols[i]));
	}
	
	tmp = (unsigned char*) calloc(len, sizeof(unsigned char));
	int bitpos = 0;
	for (i = 0; i < len; i++)
	{
		code = huffcode(&symbols[data[i]]);
		for (j = 0; j < strlen(code); j++)
		{
			tmp[bitpos>>3] ^= (code[j] - '0')<<(bitpos&0x7);
			bitpos++;
		}
	}
	len = (bitpos+7)>>3;
	memcpy(data, tmp, len);
	free(tmp);
	
	*pLen = len;
	return len;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

// POPIS read_file():

// Funkcia, ktora precita obsah suboru (fname)

// do dynamickeho pola znakov

// a vrati pointer na jeho zaciatok + dlzku.

// IN:

// fname - retazec obsahujuci nazov suboru

// pLen - pointer, kam sa zapise dlzka suboru

// OUT:

// unsigned char* - pointer na binarny obsah suboru

unsigned char* read_file(char* fname, size_t *pLen)

{

FILE * f;

size_t len,pos;

unsigned char* out;

f = fopen(fname, "rb"); // otvarame subor v binarnom rezime

if (f == NULL) // kontrolujeme, ci otvaranie prebehlo OK

return NULL;

pos = ftell(f); // aktualna pozicia

fseek(f, 0, SEEK_END); // presunieme sa na koniec suboru

len = ftell(f); // zistenie aktualnej pozicie v subore

fseek(f, pos, SEEK_SET); // vratenie sa na zaciatok suboru

out = (unsigned char*)malloc(len); // alokujeme pamat pre retazec + 1 ukoncovaci znak

if(out == NULL){

fprintf(stderr, "Alokacia pamate zlyhala.\n");

exit(-1);

}

// nacitanie suboru do retazca

fread(out, sizeof(unsigned char), len, f);

fclose(f); // zavrieme subor

//vratime dlzku a nacitane data

*pLen = len;

return out;

}

int compress(unsigned char *data, size_t *pLen);

int write_file(char* fname, unsigned char *data, size_t len)

{

FILE *f = fopen(fname, "wb");

if (f == NULL)

return 0;

fwrite(data, sizeof(unsigned char), len, f);

fclose(f);

return 1;

}

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

{

size_t len, ones;

unsigned char * data;

char *fname = "test.bmp";

if (argc >= 2)

fname = argv[1];

data = read_file(fname, &len);

if (data != NULL)

{

compress(data, &len);

write_file("huff.out", data, len);

free(data);

}

return 0;

}

#define NSYM 256

typedef struct _symbol {

int code;

int count;

struct _symbol *parent;

struct _symbol *zero, *one;

} Symbol;

char* huffcode(Symbol* pSymbol)

{

static char str[NSYM + 1] = "";

int i = NSYM-1;

while (pSymbol->parent != 0)

{

if (pSymbol->parent->zero == pSymbol)

str[i] = '0';

else

str[i] = '1';

i--;

pSymbol = pSymbol->parent;

}

return &str[i+1];

}

//PRE: symbols len is 2n

int huffman(Symbol symbols[], int n)

{

int i, from = 0, to = n;

Symbol* tmp;

Symbol* ptrs[2*n];

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

ptrs[i] = &symbols[i];

while (to - from > 1)

{

//prve dve su minimum

for (i = from+1; i < to; i++)

{

if (ptrs[i]->count < ptrs[from]->count)

{

tmp = ptrs[from];

ptrs[from] = ptrs[i];

ptrs[i] = tmp;

}

if (ptrs[i]->count < ptrs[from+1]->count)

{

tmp = ptrs[from+1];

ptrs[from+1] = ptrs[i];

ptrs[i] = tmp;

}

//pridaj na koniec novy uzol...

ptrs[to]->code = -1;

ptrs[to]->count = ptrs[from]->count +

ptrs[from+1]->count;

ptrs[to]->zero = ptrs[from];

ptrs[to]->one = ptrs[from+1];

ptrs[from]->parent = ptrs[to];

ptrs[from+1]->parent = ptrs[to];

to++;

from += 2;

}

int compress(unsigned char *data, size_t *pLen)

{

Symbol symbols[2*NSYM] = {0};

Symbol* pRoot;

unsigned char *tmp;

char *code;