2017.05.29. Access ECDL

Ellenőriztük a 40-41-es feladatot.

Házi feladat a vizsgáig folyamatosan tanulni a megoldásokat, amiket eddig vettünk. A megoldásos doksi elején a kék szöveget vedd át újra és újra.

Koncentráljatok a következőkre:
- Szövegértés: csináld azt és csak azt és mindazt, amit kér a feladat. Ha kész, olvasd el még egyszer.
- A lekérdezéseket jól nézd meg, a két pontos feladatok pontszáma nem bontható, és kis odafigyeléssel meg lehet oldani a 90%-át helyesen. Segítségképpen tanuld meg a lekérdezéses feladatlap megoldását.
- Az űrlapoknál nem mindegy, egyszerre egy vagy több rekord látszik. Ha kész az űrlap, győződj meg róla. Minden címke és adatmező legyen látható akkor is, ha nem mondja a feladat.
- A jelentéseket meg kell oldani, amit eddig feladtál, mert nehéznek találtad. Jelentés nélkül nincs sikeres vizsga, ahhoz túl sok pontot ér.  Minden címke és adatmező legyen látható akkor is, ha nem mondja a feladat.

2017.05.29. ECDL ACCESS lekérdezés gyakorló feladatlap megoldás megosztása

Megosztottam a lekérdezéses feladatlap megoldását. Az eredeti feladatlapon kicsit változtattam, és ki is egészítettem további feladatokkal. Aki ezeket megérti, és tudja reprodukálni, az valószínűleg a vizsgán is boldogulni fog a nem kifejezetten bonyolult lekérdezésekkel. Lesz belőle dolgozat, és kell vizsgán, tessék tanulni.

2017.05.28. Évvégi hajrá

06.01.	csütörtök	algoritmusok tz papíron (elmélet)
06.02.	péntek	a papíron is kiadott lekérdezéses feladatlapból 15 perces röpdolgozat (elmélet)
06.06.	kedd	Access Ecdl jelentésekből 15 perces röpdolgozat (gyakorlat)
06.08.	csütörtök – 1. óra	while ciklus tz (gyakorlat)
06.08.	csütörtök – 2. óra	próba access ecdl vizsga
06.12.	hétfő	access ecdl vizsga

2017.05.28. Nem faktosok - pótlás

További megoldandó feladatok a nem faktosoknak: 40-től 43-ig.

2017.05.25. Ecdl Access

Ellenőriztük a 11-es feladatban a nehezebb feladatok megoldását a megosztott
ECDL ADATBÁZIS-KEZELÉS példatár részleges megoldásokkal

doksi alapján.

2017.05.25. Alap algoritmusok gyakorlása

A lenti megoldást a megosztott algoritmusos feladatlapból emeltük át, tedd be a füzetedbe.
A lenti kódot meg kell érteni, és meg kell tanulni (nem bemagolni!). Tudni kell alkalmazni.
06.01-én témazáró dolgozat lesz belőle, ami elméleti jegy lesz, és papíron írjuk.

            //Kiválasztás tétele

            //Adjuk meg, hogy hányadik a tömbben az 55, és írjuk ki

            //a sorszámát! Ha több is van, csak az elsőt írjuk ki. Ha nincs ilyen szám, írjunk ki hibaüzenetet!

        

            Random rnd = new Random();

            int[] szamok = new int[5];

           

            int i = 0;

            while (i < szamok.Length)

            {

                szamok[i] = rnd.Next(0, 101);

                Console.WriteLine(szamok[i]);

                i++;

            }

            i = 0; //használjuk az i-t, csak nullázni kell

            while (i < szamok.Length && szamok[i] != 55) //végig is tudjon menni, és meg is tudjon állni, ha kell

                                                         // a ciklus feltételében vizsgáljuk a megadott feltétel teljesülését

            {

                i++;

            }

            if (i != szamok.Length)

                Console.WriteLine("A keresett szám (55) a {0}. indexű elem.", i);

            else

                Console.WriteLine("A keresett szám (55) nincs a tömbben!");

            Console.ReadLine();

            ///////////////////////////////////

            //A megszámlálás tétele

            //Számoljuk meg egy tömbben az 50 alatti elemeket! Írjuk ki a végeredményt. (For ciklussal is jó.)

            i = 0;  //használjuk az i-t, csak nullázni kell

            int db = 0;

            while (i < szamok.Length)

            {

                if (szamok[i] < 50)

                {

                    db++;

                }

                i++;

            }

            Console.WriteLine("{0} db 50 alatti szám van a tömbben.", db);

            Console.ReadLine();

            ////////////////////////////////

            //         Az eldöntés tétele

            //Döntsük el, hogy van-e a tömbben 10-nél nagyobb szám. Amennyiben találtunk egyet, a ciklus

            //         álljon meg, és írjuk ki a képernyőre a megtalált elemet. (Nem kell a többit is megkeresni.)

            //         Ha végigmentünk a tömbön, és nem találtunk egyet sem, azt is írjuk ki.

            i = 0; //használjuk az i-t, csak nullázni kell

            bool van = false;

            while (i < szamok.Length && !van)  //végig is tudjon menni, és meg is tudjon állni, ha kell - logikai változóval

            // a ciklus törzsében egy logikai változó segítségével vizsgáljuk a megadott feltétel teljesülését

            {

                if (szamok[i] > 10)

                    van = true;

                i++;

            }

            if (van)

                Console.WriteLine("Van a tömbben 10-nél nagyobb elem: {0}", szamok[i - 1]);

            else

                Console.WriteLine("Nincs a tömbben 10-nél nagyobb elem.");

            Console.ReadLine();

            ////////////////////////////////

            //A kiválogatás tétele

            //Adott két azonos elemszámú tömb. Másoljuk át az első tömbből a másodikba a páros elemeket.

            int[] szamok1 = new int[5];

            int[] szamok2 = new int[5];

            int j = 0; //a második tömb miatt kell

            for (i = 0; i < szamok1.Length; i++)  //itt az i elé nem szabad típusmegadást írni (tehát nem kell az int),

                //mert az i-t már létrehoztuk a főprogramban, és itt a for cikluson belül is látjuk

            {

                if (szamok1[i] % 2 == 0)

                {

                    szamok2[j] = szamok1[i];

                    j++;

                }

            }

            Console.ReadLine();

            ///////////////////////////////

            //Az összegzés tétele

            //Egy tömbben add össze az elemeket. Írd ki a végeredményt.

            int osszeg = 0;

            for (i = 0; i < szamok.Length; i++)

            {

                osszeg = osszeg + szamok[i];

            }

            Console.WriteLine("A tömbelemek összege: {0}", osszeg);

            Console.ReadLine();

            //Változat: Add össze a páros elemeket. Írd ki a végeredményt.

            int parosOsszeg = 0;

            for (i = 0; i < szamok.Length; i++)

            {

                if (szamok[i] % 2 == 0)

                    parosOsszeg = parosOsszeg + szamok[i];

            }

            Console.WriteLine("A páros elemek összege: {0}", parosOsszeg);

            Console.ReadLine();

            //Változat: Szorozd össze az 50-nel osztható elemeket. Írd ki a végeredményt.

            int szorzat = 1;

            van = false;

            for (i = 0; i < szamok.Length; i++)

            {

                if (szamok[i] % 50 == 0)

                {

                    szorzat = szorzat * szamok[i];

                    van = true;

                }

            }

            if (van) //ha nem volt megfelelő szám, akkor 1-et írna ki a program enélkül

            {

                Console.WriteLine("Az 50-nel osztható elemek szorzata: {0}", szorzat);

            }

  

           

            Console.ReadLine();

            //////////////////////////////

            //A minimumkeresés tétele

            //Egy tömbben keresd meg a legkisebb elemet.

            int min = szamok[0];

            for (i = 1; i < szamok.Length; i++)

            {

                if (szamok[i] < min)

                    min = szamok[i];

            }

            Console.WriteLine("A legkisebb elem: {0}", min);

            Console.ReadLine();

            //////////////////////////////////

            //A maximumkeresés tétele

            //Egy tömbben keresd meg a legnagyobb elemet.

            int max = szamok[0];

            for (i = 1; i < szamok.Length; i++)

            {

                if (szamok[i] > max)

                    max = szamok[i];

            }

            Console.WriteLine("A legnagyobb elem: {0}", max);

            Console.ReadLine();

2017.05.25. Nem faktosok - pótlás

Aki nem info faktos, önkéntes alapon házi feladat megoldani a következő feladatsorokat: 25-33. Érdemes folyamatosan foglalkozni vele, naponta-kétnaponta egy-egy feladatsort megoldani. A megoldásokat megbeszéljük, ha hozod.
Továbbra is ajánlom, hogy be lehet jönni faktra gyakorolni minden kötelezettség nélkül, aki tud.

2017.05.23. Access Ecdl gyakorlás

Összevont óra.
ECDL vizsga.
Access Ecdl feladat: 34. önállóan, vagy párban. Aki ma hiányzik, házi feladat megoldani.

2017.05.22. Házi feladat - Pályázat

1.      feladat:

-        Kérd be a felhasználótól, hogy hány nap múlva lesz az uniós pályázat beadási határideje.

-        Számolj visszafelé egyesével 1-ig, az aktuális értéket írd ki a képernyőre. Amikor eljött a határidő napja, írd ki, hogy ma van a határidő napja.

            Console.WriteLine("Hány nap múlva van a határidő?");

            int nap = Convert.ToInt32(Console.ReadLine());

            while (nap > 0)

            {

                Console.WriteLine("{0} nap van még.",nap);

                nap--;

            }

            Console.WriteLine("Ma van a határidő napja.");

2.      feladat:

Középiskolák pályázhattak hardver beszerzésre. A teljes pályázati összeg 10 millió forint. Százezer, kétszázezer, háromszázezer forintokra lehetett pályázni.

Modellezzük az iskolák igényét úgy, hogy a százezer forintot véletlenül szorozzuk be cikluslépésenként 1-2-3-mal.

-        A ciklus addig megy, amíg el nem fogy minden pénz.

-        Minden cikluslépésben írd ki, hogy mennyit kapott a pályázó és mennyi pénz van még. 

A végén ne menjen mínuszba, az utolsó pályázó a maradék összeget kapja.

Random rnd = new Random();

            double maxOsszeg = 10000000;

            double aktualisIskolaOsszeg = 0;

            int i = 0;                      

            while (maxOsszeg > 0)

            {

                aktualisIskolaOsszeg = 100000 * rnd.Next(1, 4);

                if ((maxOsszeg - aktualisIskolaOsszeg) > 0)

                {

                    maxOsszeg = maxOsszeg - aktualisIskolaOsszeg;

                    Console.WriteLine("A(z) {0}. iskola nyert {1} forintot. Maradt még:{2}Ft!", i+1, aktualisIskolaOsszeg, maxOsszeg);

                }

                else

                {

                    if ((maxOsszeg - aktualisIskolaOsszeg) == 0)

                    {

                        maxOsszeg = 0;

                        Console.WriteLine("A(z) {0}. iskola nyert {1} forintot. Maradt még:{2}Ft!", i + 1, aktualisIskolaOsszeg, maxOsszeg);                       

                    }

                    else //akkor kisebb

                    {

                        Console.WriteLine("A(z) {0}. iskola nyert {1} forintot. Maradt még:{2}Ft!", i + 1, maxOsszeg, 0);

                        maxOsszeg = 0;                      

                    }

                }

                i++;

            }

2017.05.22. Alap algoritmusok

Dolgozat kiosztás.
Elméleti és access gyak. dolgozat pótlás.
Alap algoritmusok: összegzés tételének verziói: ellenőrzés és megvalósítás programban.

2017.05.19. Access ECDL önálló feladatmegoldás

11-12. feladatsor
Házi feladat a másik csoport feladatsorát megoldani (aki a 11-est írta, az a 12-est oldja meg otthon és fordítva).

A nem info faktosok további feladatot is kapnak: a 25. feladatsort.

A házikat hétfőre kell megoldani.

2017.05.18. Alap algoritmusok

Megoldottuk az alap algoritmusos feladatlap elejét: kiválasztás, megszámlálás, eldöntés tétele. Házi feladat az összegzés tételének minden verzióját megoldani papíron. Aki hiányzott, fájlban oldja meg, és feltölti a drive-ra.

2017.05.18. Ecdl Access

Megoldottuk a gyakorló feladatlap elejét, az első blokkot végig, majd a második blokkból a 10-es feladatig. Házi feladat a második oldalt befejezni.

2017.05.15. ECDL Access

Számonkérés.
8-9. feladatsor ellenőrzésére nem került sor, mivel a többségnek nem volt házi feladata.
10. feladatsor.
Házi feladat: akinek kell, pótolni a 8-9-et.
Mindenkinek: befejezni a 10-est.

2017.05.11. 1 While ciklus bevezetés - megoldás

A következő órától kezdve a tanári gépnél, kivetítővel felelni fogunk órák elején. Feladat 1-2 kisebb feladat megoldása ciklussal (for-, foreach-, while).
            
//While ciklus bevezetés

            //Feladat: Töltsünk fel egy 10 elemű

            //int tömböt véletlen számokkal!

            Console.WriteLine("Tömb létrehozása...");

            int[] szamok = new int[10];

            Random rnd = new Random();

            //Megoldás for ciklussal (plusz kiírás):

            Console.WriteLine("Feltöltés, kiírás for ciklussal:");

            for (int k = 0; k < szamok.Length; k++)

            {

                szamok[k] = rnd.Next(100);

                Console.WriteLine(szamok[k]);

            }

            Console.ReadLine();

            //Megoldás while ciklussal (plusz kiírás):

            //(i: itt is ciklusváltozó)

            Console.WriteLine("Feltöltés, kiírás while ciklussal:");

            int i = 0;

            while (i < szamok.Length)

            {

                szamok[i] = rnd.Next(100);

                Console.WriteLine(szamok[i]);

                i++;

            }

            Console.ReadLine();

            //Összegzés tétele for ciklussal:

            Console.WriteLine("Összegzés for ciklussal:");

            int osszeg = 0;

            for (int m = 0; m < szamok.Length; m++)

            {

                osszeg = osszeg + szamok[m];

            }

            Console.WriteLine("Összeg for ciklussal: {0}", osszeg);

            //Összegzés tétele while ciklussal: 

            Console.WriteLine("Összegzés while ciklussal:");

            osszeg = 0;

            i = 0;

            while (i < szamok.Length)

            {

                osszeg = osszeg + szamok[i];

                i++;

            }

            Console.WriteLine("Összeg while ciklussal: {0}", osszeg);

            Console.ReadLine();

            //Gyakorló feladatok while ciklusra:

            //1. feladat:

            //Írjuk ki az első 100 természetes számot

            //a képernyőre! (0,1,2,3...98,99)

            Console.WriteLine("Az első 100 természetes szám következik:");

            Console.ReadLine();

            i = 0;

            while (i < 100) //Nullától 99-ig, tehát 100-szor fut

            {

                Console.WriteLine(i); //ha a ciklusváltozót íratjuk ki, pont jó lesz

                i++;

            }

            //Itt használhatjuk a ciklusváltozót a kiíráshoz, ez nem mindig ilyen egyszerű.

            //Ha ennél összetettebb a feladat, akkor érdemes lehet egy új változót bevezetni, később lesz erre még példa.

            Console.ReadLine();

            //2. feladat:

            //Írjuk ki az első 100 darab 2-vel osztható

            //természetes számot

            //a képernyőre! (0,2,4...)

            Console.WriteLine("Az első 100 darab 2-vel osztható természetes szám következik:");

            Console.ReadLine();

            i = 0;

            int db = 0;

            while (db < 100) //itt arra koncentrálunk, hogy biztos pontosan 100-szor fusson

                //ezért nem jó az i, mert 100-nál több számot kell végignéznünk egyesével

                //és az i-t arra használjuk, hogy ezeken végigmenjünk

            {

                if (i % 2 == 0)

                {

                    Console.WriteLine(i);

                    db++; //csak akkor emeljük ezt az értéket, ha tényleg találtunk egy feltételnek megfelelő számot

                }

                i++; //mivel minden számot meg kell nézni, egyesével növeljük az i-t

            }

            Console.ReadLine();

            //3. feladat:

            //Írjuk ki az első 10 darab 10-zel osztható

            //természetes számot

            //a képernyőre!

            //(Nagyon hasonlít az előzőre.)

            Console.WriteLine("Az első 10 10-zel osztható természetes szám következik:");

            Console.ReadLine();

            i = 0;

            db = 0;

            while (db < 10)

            {

                if (i % 10 == 0)

                {

                    Console.WriteLine(i);

                    db++;

                }

                i++;

            }

            Console.ReadLine();

            //4. feladat:

            //Kérjünk be karaktereket a felhasználótól

            //egy 5 elemű tömbbe!

            Console.WriteLine("5 karakter bekérése következik.");

            char[] karakterek = new char[5];

            i = 0;

            while (i < karakterek.Length)

            {

                Console.WriteLine("Kérek egy karaktert!");

                karakterek[i] = Convert.ToChar(Console.ReadLine());

                i++;

            }

            Console.ReadLine();

            //5. feladat:

            //Addig írjuk ki a képernyőre a számokat egyesével

            //százegytől indulva, amíg nem találunk egy olyan számot,

            //ami osztható 23-mal.

            Console.WriteLine("Ami 23-mal osztható, azt már nem írjuk ide:");

            Console.ReadLine();

            i = 101; //itt beállítjuk a kezdőértéket, az első számot; amit először ki kell írni

            while (!(i % 23 == 0)) //addig menjen, amíg MÉG NEM talált a feltételnek megfelelőt

                //1. a feltételt könnyen meg tudjuk fogalmazni, mert az oszthatóságot könnyen kiszámoljuk

                //2. eztán már csak tagadni kell, hogy fusson az a ciklus...

            {

                Console.WriteLine(i); //mivel egyesével minden számot ki kell írni, használhatjuk a ciklusváltozót

                i++;

            }

            Console.ReadLine();

            //6. feladat:

            //Addig írjuk ki a képernyőre a számokat egyesével

            //20-tól indulva, amíg nem találunk egy olyan számot,

            //ami osztható 3-mal, 4-gyel, és 5-tel is.

            //(3*4*5=60 előtt kell neki megállni.)

            Console.WriteLine("Ami osztható 3-mal, 4-gyel, és 5-tel is, előtte megállunk:");

            Console.ReadLine();

            i = 20;

            while (!(i % 3 == 0 && i % 4 == 0 && i % 5 == 0))

                //mint az előző feladat, csak összetett a feltétel

                //1. fogalmazzuk meg úgy, mintha csak a 3-mal oszthatóságot kellene figyelni

                //2. találjuk ki, milyen logikai operátor (művelet) kell ahhoz, hogy együtt legyen igaz a 3-mal, és a 4-gyel való oszthatóság, ez az:&&

                //3. bővítsük ki az utolsó résszel

                //4. tagadjuk, hogy addig fusson a ciklus, míg ilyet nem talál

            {

                Console.WriteLine(i);

                i++;

            }

            Console.ReadLine();

            //Tehát a for ciklusnál rugalmasabb ciklus abból a szempontból,

            //hogy nincs előre meghatározva a lépésszáma.