C programozás oktatás kezdőknek
Kérdésed van? +36 70 410 1763 info@c-programozas.hu

Lottó

Érettségi feladat - 2005. május 19.

Magyarországon 1957 óta lehet ötös lottót játszani. A játék lényege a következő: a lottószelvényeken 90 szám közül 5 számot kell a fogadónak megjelölnie. Ha ezek közül 2 vagy annál több megegyezik a kisorsolt számokkal, akkor nyer. Az évek során egyre többen hódoltak ennek a szerencsejátéknak és a nyeremények is egyre nőttek. 

Adottak a lottosz.dat szöveges állományban a 2003. év 51 hetének ötös lottó számai. Az első sorában az első héten húzott számok vannak, szóközzel elválasztva, a második sorban a második hét lottószámai vannak, stb. 

A lottószámok minden sorban emelkedő számsorrendben szerepelnek. Az állományból kimaradtak az 52. hét lottószámai. Ezek a következők voltak: 89 24 34 11 64.

Készítsünk programot a következő feladatok megoldására! 

Kérjük be a felhasználótól az 52. hét megadott lottószámait! (2 pont)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
#define M 5

void beker(int nyeroszamok[]){
	int i;
	printf("Adja meg az 52. hét lottószámait!\n");
	for(i=0;i<M;i++){
		printf("%d. szám: ",i+1);
		scanf("%d",&nyeroszamok[i]);
	}
}

Deklaráljunk egy konstanst, ami tárolja a nyerőszámok számát. Készítsünk függvényt a feladat megvalósításához, amelynek paraméterként adjuk meg azt a tömböt, amiben a nyerőszámokat szeretnénk tárolni, majd a függvény törzsében olvassuk be ciklus segítségével az adatokat.

Rendezzük a bekért lottószámokat emelkedő sorrendbe! A rendezett számokat írjuk ki a képernyőre! (5 pont)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
#define M 5

void rendez(int nyeroszamok[]){
	int i,j,cs;
	/* Buborék rendezés */
	for(i=0;i<M-1;i++){
		for(j=M-1;j>=i+1;j--){
			if(nyeroszamok[j]<nyeroszamok[j-1]){
				cs=nyeroszamok[j];
				nyeroszamok[j]=nyeroszamok[j-1];
				nyeroszamok[j-1]=cs;
			}
		}	
	}
	printf("\nA megadott lottószámok növekvő sorrendben:\n");
	for(i=0;i<M;i++){
		printf("%d ",nyeroszamok[i]);
	}
	printf("\n");
}

A lottószámok növekvő sorrendbe rendezéséhez használjunk buborékrendezést. Az algoritmus a nevét onnan kapta, hogy először a legnagyobb elem kerül a tömb utolsó helyére, utána a második legnagyobb az azt követő helyre, és így tovább. A folyamat hasonlítható ahhoz, ahogy a buborékok felfelé szállnak egy szénsavas italban. A feladathoz természetesen más rendező algoritmus is megfelelő lenne.

Kérjünk be a felhasználótól egy egész számot 1-51 között! (1 pont)

1
2
3
4
5
6
int het_beker(void){
	int n;
	printf("\nAdjon meg egy számot 1 és 51 között!\n");
	scanf("%d",&n);
	return n;
}

A het_beker függvény visszatérési értéke a felhasználótól bekért hét legyen (a bekért számot nem kell ellenőrizni).

Írjuk ki a képernyőre a bekért számnak megfelelő sorszámú hét lottószámait, a lottosz.dat állományban lévő adatok alapján! (7 pont)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#define M 5

int beolvas(char *fajlnev, int lottoszamok[][M]){
	FILE *fp = fopen(fajlnev,"r");
	int i=0,j;
	if(fp==NULL){
		return 0;
	}
	while(!feof(fp)){
		for(j=0;j<M;j++){
			fscanf(fp,"%d",&lottoszamok[i][j]);
		}
		i++;
	}
	fclose(fp);
	return 1;
}

void het_lottoszamai(int lottoszamok[][M], int het){
	int i;
	printf("A(z) %d. hét lottószámai:\n",het);
	for(i=0;i<M;i++){
		printf("%d ",lottoszamok[het-1][i]);
	}
	printf("\n");
}

A beolvas függvény első paramétere az adatokat tartalmazó fájl neve, a második pedig egy kétdimenziós egész tömb, amelybe a beolvasott nyerőszámokat tároljuk. A függvény törzsében nyissuk meg a fájlt, és olvassuk be a lottószámokat.

A het_lottoszamai függvény segítségével határozzuk meg a bekért sorszámú hét nyerőszámait. A függvény első paramétere az adatokkal feltöltött nyerőszámok tömbje, a második pedig a hét sorszáma.

A lottosz.dat állományból beolvasott adatok alapján döntsük el, hogy volt-e olyan szám, amit egyszer sem húztak ki az 51 hét alatt! A döntés eredményét (Van/Nincs) írjuk ki a képernyőre! (5 pont)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
#define N 51
#define M 5
#define MAX 90

int volt_mind(int lottoszamok[][M]){
	int stat[MAX]={0},i,j;
	for(i=0;i<N;i++){
		for(j=0;j<M;j++){
			stat[lottoszamok[i][j]]++;
		}
	}
	for(i=0;i<MAX;i++){
		if(!stat[i]){
			return 0;
		}
	}
	return 1;
}

Haladjunk végig a beolvasott nyerőszámokon, és készítsünk előfordulási statisztikát. Ha volt olyan szám, amit nem húztak ki, akkor a függvény visszatérési értéke nulla (hamis), különben pedig egy (igaz) legyen.

A lottosz.dat állományban lévő adatok alapján állapítsuk meg, hogy hányszor volt páratlan szám a kihúzott lottószámok között! Az eredményt írjuk ki a képernyőre! (5 pont)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
#define N 51
#define M 5

int paratlan_szamok(int lottoszamok[][M]){
	int db=0,i,j;
	for(i=0;i<N;i++){
		for(j=0;j<M;j++){
			if(lottoszamok[i][j]%2!=0){
				db++;
			}
		}
	}
	return db;
}

Haladjunk végig a beolvasott nyerőszámokon, és határozzuk meg azon számok darabszámát, amelyek kettővel osztva nem nulla maradékot adnak, azaz páratlanok. A függvény visszatérési értéke a kapott szám legyen.

Fűzzük hozzá a lottosz.dat állományból beolvasott lottószámok után a felhasználótól bekért, és rendezett 52. hét lottószámait, majd írjuk ki az összes lottószámot a lotto52.ki szöveges fájlba! A fájlban egy sorba egy hét lottószámai kerüljenek, szóközzel elválasztva egymástól! (7pont)

 

Határozzuk meg a lotto52.ki állomány adatai alapján, hogy az egyes számokat hányszor húzták ki 2003-ban. Az eredményt írjuk ki a képernyőre a következő formában: az első sor első eleme az a szám legyen, ahányszor az egyest kihúzták! Az első sor második eleme az az érték legyen, ahányszor a kettes számot kihúzták, stb.! (Annyit biztosan tudunk az értékekről, hogy mindegyikük egyjegyű.) (6 pont)

 

Adjuk meg, hogy az 1-90 közötti prímszámokból melyiket nem húzták ki egyszer sem az elmúlt évben. A feladat megoldása során az itt megadott prímszámokat felhasználhatjuk vagy előállíthatjuk! (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89.) (7 pont)

 

A főprogram

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <stdio.h>
#include <locale.h>

#define N 51
#define M 5
#define MAX 90

/* Függvények... */

int main(void){
	int nyeroszamok[M],lottoszamok[N][M],n;
	
	setlocale(LC_ALL, "");
	
	/* 1. feladat */
	beker(nyeroszamok);
	
	/* 2. feladat */
	rendez(nyeroszamok);
	
	/* 3. feladat */
	n=het_beker();
	
	/* 4. feladat */
	if(!beolvas("lottosz.dat",lottoszamok)){
		printf("A lottosz.dat fájl nem található! A program kilép.\n");
		return 1;
	}
	het_lottoszamai(lottoszamok,n);
	
	/* 5. feladat */
	if(volt_mind(lottoszamok)){
		printf("\nVolt olyan szám, amit egyszer sem húztak ki!\n");
	}
	else{
		printf("\nNem volt olyan szám, amit egyszer sem húztak ki!\n");
	}
	
	/* 6. feladat */
	printf("\nPáratlan számot %d alkalommal húztak.\n",paratlan_szamok(lottoszamok));
	
	return 0;
}

Hívjuk meg a fent bemutatott függvényeket a főprogramban, és jelenítsük meg a képernyőn a kapott eredményeket.

A program egy lehetséges kimenete

Adja meg az 52. hét lottószámait!
1. szám: 89
2. szám: 24
3. szám: 34
4. szám: 11
5. szám: 64

A megadott lottószámok növekvő sorrendben:
11 24 34 64 89

Adjon meg egy számot 1 és 51 között!
8
A(z) 8. hét lottószámai:
10 21 29 40 87

Nem volt olyan szám, amit egyszer sem húztak ki!

Páratlan számot 126 alkalommal húztak.

  Az itt található érettségi feladat megoldása nem az Oktatási Minisztérium által kiadott hivatalos megoldás. A feladatokat azért dolgoztam ki C nyelven is, hogy segítsem a diákjaim sikeres emelt szintű érettségi felkészülését. A megoldások irányadó jellegűek, a feladatok többféleképpen is megoldhatóak.

  Ha a lakattal jelölt feladatok megoldásaira is kíváncsi vagy, keress bizalommal!