2017. június 19., hétfő

2017.06.19. Nyári gyakorlat 1. nap

1. Ismétlés, gyakorlás: a legutolsó gyakorló feladatsort oldottuk meg.

http://programozas11b1.blogspot.hu/2017/06/20170605-ciklusos-feladatok-otthoni.html

2. Új anyag: egymásba ágyazott ciklusok

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace egymasbaAgyazottCiklusok
{
    class Program
    {
        static void Main(string[] args)
        {
            //1.  feladat:
            // A külső ciklus 10-szer fusson le, minden ciklusmagban írja ki,
            //hogy hányadik külső ciklus-lépésben járunk.
            // A belső ciklus 5-ször fusson, (futásonként) írja ki, hogy ő a belső ciklus,
            //és írjon még ki egy véletlenszámot.
            Console.WriteLine("1. feladat");
            int i = 0;
            int j = 0;
            Random rnd = new Random();
            while (i < 5)
            {
                Console.WriteLine("Külső ciklus: {0}", i + 1);
                j = 0;
                while (j < 3)
                {
                    Console.WriteLine("                         én vagyok a {0}. belső ciklus: {1}", j+1, rnd.Next(0, 100));
                    j++;
                }


                i++;
            }

            Console.ReadLine();


            //2.  feladat:
            // Módosítsuk az előző feladatot úgy, hogy a külső és a belső ciklus más-más színnel írjon a képernyőre.

            Console.WriteLine("2. feladat");
            i = 0;
            while (i < 10)
            {
                Console.BackgroundColor = ConsoleColor.Red;
                Console.ForegroundColor = ConsoleColor.Blue;
                Console.WriteLine("Külső ciklus: {0}", i + 1);
                j = 0;

                while (j < 5)
                {
                    Console.BackgroundColor = ConsoleColor.Black;
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.WriteLine("                         én vagyok a belső ciklus: {0}", rnd.Next(0, 100));
                    j++;

                }


                i++;

            }
            Console.ResetColor();
            Console.ReadLine();


            //3.  feladat:
            // Lépésenkénti futtatással vizsgáljuk meg a ciklusok működését.


            //4.  feladat:
            // Hozz létre egy 20 elemű string tömböt, melyben 10 számjegyből
            //álló titkos kódokat fogsz tárolni.
            // Külső ciklus:
            //•  menj végig minden tömbelemen;
            //•  helyezz el a tömbelemben egy stringgé alakított véletlen számjegyet;
            // Belső ciklus, ami 9-szer ismétlődik:
            //•  lépésenként adj hozzá a tömbelem aktuális tartalmához egy, a fenti módon
            //stringgé alakított véletlen számjegyet úgy, hogy egy stringet alkossanak.
            // A külső ciklusból kilépve listázd ki a képernyőre a tömböt.


A következő feladatmegoldás a 4-es feladat továbbfejlesztése:
            Console.WriteLine("4. feladat");
            string[] titkos = new string[20];
            i = 0;
            while (i < 20)
            {
                titkos[i] = Convert.ToString(Convert.ToChar(rnd.Next(65, 90)));//nagybetű
                Console.WriteLine(titkos[i]);
                j = 0;
                while (j < 8)
                {
                    titkos[i] = titkos[i] + Convert.ToString(rnd.Next(0, 10)); //számjegy
                    Console.WriteLine(titkos[j]);
                    j++;
                }
                titkos[i] = titkos[i] + Convert.ToString(Convert.ToChar(rnd.Next(97, 122)));
//kisbetű
                Console.WriteLine(titkos[i]);
                i++;
            }
            Console.ReadLine();





            //5.  feladat:
            //–  Oldd meg, hogy a listázás a ciklusok futása közben megvalósuljon,
            //ehhez keresd meg azt a helyet, ahová a kiírást el kell helyezni.

            Console.WriteLine("5. feladat, a 4-es eredeti megoldása alapján");
            string[] titkos2 = new string[20];
            i = 0;
            while (i < 20)
            {
                titkos2[i] = Convert.ToString(rnd.Next(0, 10));
                Console.WriteLine(titkos2[i]);
                j = 0;
                Console.WriteLine(titkos2[i]);
                while (j < 9)
                {
                    titkos2[i] = titkos2[i] + Convert.ToString(rnd.Next(0, 10));
                    j++;
                    Console.WriteLine(titkos2[i]);
                }

                i++;
            }
            Console.ReadLine();
            //6.  feladat:
            // Az órai munka minden feladatát futtasd lépésenként, vizsgáld a műveleteket, változókat.

            Console.WriteLine("6. feladat");

            //7.  feladat:
            // Ismételd meg tízszer a Beep() metódus segítségével
            //a Morse SOS (. . . – – – . . .) jelet
            //(a harmadik leckében találsz hozzá segítséget).
            //A külső ciklus 10-szer fusson, ezen belül fusson
            //3 belső ciklus.
            //Az első ismételje 3-szor a rövid hangot;
            //a második ismételje 3-szor a hosszú hangot,
            //a harmadik ugyanaz, mint az első.
            //Módosítás: ne hangot adjon a program, hanem
            //írja ki a jeleket.

            Console.WriteLine("7. feladat");

            i = 0;
            int K = 0;
            while (i < 10)
            {
                K = 0;
                while (K < 3)
                {
                    Console.Write(".");
                    K++;
                }
                j = 0;
                while (j < 3)
                {
                    Console.Write("-");
                    j++;
                }
                K = 0;
                while (K < 3)
                {
                    Console.Write(".");
                    K++;
                }
             
                i++;

            }

            //8.  feladat:
            //–  Hangokkal kódold le a végén a TITANIC szót (ehhez ne használj ciklust)

            Console.WriteLine("8. feladat");


            Console.ReadLine();
        }
    }
}

További feladat: Írjuk tele a képernyőt (soronként, azon belül oszloponként) egyesével valamilyen karakterrel.

2017. június 6., kedd

2017. június 5., hétfő

2017.06.05. Ciklusos feladatok otthoni gyakorláshoz - nem kötelező házi feladat

Az alapalgoritmusokat az eddigi feladatok alapján önállóan gyakorold.
További gyakorló feladatok:

//Írd ki az első 30 db 4-gyel osztható számot.

//Írjuk ki a betűket a-tól kezdve z-ig.

//500-tól számolj visszafelé 10-esével 100-ig (írd ki őket).

//Hozz létre egy 10 elemű karaktertömböt kisbetu néven.  Töltsd föl az angol abc első 10 kisbetűjével.

//Írd ki a tömb első felét nagy betűssé alakítva egy sorba, szóközzel elválasztva.


//Írjunk ki addig páratlan számokat a képernyőre, amíg
//el nem érjük a 20-at.
//Az első szám az 1 legyen.
//(1, 3, 5, ..19)

//Írjuk ki 100-tól kezdve a számokat ötösével 500-ig.
//100, 105, 110, ...500

//Töltsünk fel egy 15 elemű
//tömböt -1000 és 1000 közötti véletlen egész számokkal!

//Írd ki a tömb negatív elemeit a képernyőre.
//A kiírás így nézzen ki: "A tömb 2. eleme: -85"
//(A -85 helyére természetesen a valódi tömbelem kerüljön.)

//Töltsünk fel egy 15 elemű  double        
//tömböt 50 és 100 közötti véletlen egész számokkal!

//Írd ki a tömb 10-zel osztható elemeit a képernyőre.
//A kiírás így nézzen ki: "Tízzel osztható: 10, ez az 5. eleme a tömbnek."
//(A 10 helyére természetesen a valódi tömbelem kerüljön.)


//Írjuk ki 10-től kezdve a számokat kettesével 28-ig.
//10, 12, 14, ...28

//Írjunk ki addig 3-mal osztható egész számokat a képernyőre, amíg
//el nem érjük a 100-at.
//Az első szám a 0 legyen.
//(0, 3, 6, 9, 12, ...)
//Írjunk ki addig 3-mal osztható számokat a képernyőre, amíg
//el nem érjük a 100-at.
//Az első szám a 30 legyen.
//(30, 33, 36, …)

//Írjuk ki 0-tól kezdve a számokat tizesével 300-ig.
//0, 10, 20, ...300

//Töltsünk fel egy 20 elemű    
//tömböt -300 és 100 közötti véletlen egész számokkal!

//Írd ki a tömb pozitív elemeit a képernyőre.
//A kiírás így nézzen ki: "A tömb 2. eleme: 6"
//(A számok helyére természetesen a valódi sorszám és tömbelem kerüljön.)

//Töltsünk fel egy 30 elemű  double                
//tömböt 100 és 1000 közötti véletlen egész számokkal! (nem tévedés, egész számokkal)


//Írd ki a tömb 5-tel osztható elemeit a képernyőre.
//A kiírás így nézzen ki: "Öttel osztható: 500, ez az 15. eleme a tömbnek."
//(A számok helyére a valóságnak megfelelő értékek kerüljenek.)


//Írjuk ki 10-től kezdve a számokat hatosával 200-ig.
//10, 16, 22, …

//Írjunk ki addig 10-zel osztható egész számokat a képernyőre, amíg
//el nem érjük a tízezret.
//Az első szám az 1000 legyen.
//(1000, 1010, 1020, ...)

//Töltsünk fel egy 15 elemű  double                
//tömböt -50 és 10 közötti véletlen double számokkal!

//Írd ki a tömb negatív elemeit a képernyőre.
//A kiírás így nézzen ki: "Negatív: -10, ez az 5. sorszámú eleme a tömbnek." (nem index!)
//(A -10 helyére természetesen a valódi tömbelem kerüljön.)

//Írjuk ki 1-től kezdve a számokat kettesével 50-ig.
//1, 3, 5, 7, ...

//Írjunk ki addig 15-tel osztható egész számokat a képernyőre, amíg
//el nem érjük az 1500-at.

//Az első szám a 90 legyen.

2017.06.01. Access ecdl

2017.06.01. Alap algoritmusok témazáró

2017. június 1., csütörtök

2017.05.31. While ciklus - Karakterkezelés I. - megoldás + házi feladat

HÁZI FELADAT:

A MEGOLDÁST A DIGIFÜZETBE BETENNI
ÁTTANULMÁNYOZNI A KÓDOT
CIKLUS AMÍG MEG NEM ÉRTED A KÓDOT
     KITÖRÖLNI A MEGOLDÁST
     EGYEDÜL MEGOLDANI
     ELLENŐRIZNI      
CIKLUS VÉGE


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace betuk
{
    class Program
    {
        static void Main(string[] args)
        {//A következő feladatokban a tömböket a feltöltés után mindig listázd ki a képernyőre.
            //Tudnivalók: az ASCII táblában a betűk kódjainak határa:
            // nagy betűk: 65-90
            // kis betűk: 97-122
            //www.asciitable.com


            //1.feladat:
            // Hozz létre egy 26 elemű karaktertömböt nagyBetu néven.
            // Töltsd föl az angol ABC nagybetűivel.
            Console.WriteLine("1.feladat.");
            char[] nagyBetu = new char[26];
            int i = 0;
            while (i < 26)
            {
                nagyBetu[i] = Convert.ToChar(i + 65);
                Console.WriteLine(nagyBetu[i]);
                i++;
            }

            Console.ReadLine();
            Console.Clear();

            //2.feladat:
            // Hozz létre egy 26 elemű karaktertömböt kisBetu néven.
            // Töltsd föl az angol ABC kisbetűivel.
            Console.WriteLine("2.feladat.");
            char[] kisBetu = new char[26];
            i = 0;
            while (i < 26)
            {
                kisBetu[i] = Convert.ToChar(i + 97);
                Console.WriteLine(kisBetu[i]);
                i++;
            }


            Console.ReadLine();
            Console.Clear();

            //3.feladat:
            // Hozz létre egy 2*26=52 elemű karaktertömböt osszesbetu néven.
            // Másold át ebbe a tömbbe az előző két tömb tartalmát egymás után.
            Console.WriteLine("3.feladat.");
            char[] osszesBetu = new char[52];
            i = 0;
            while (i < 26)
            {
                osszesBetu[i] = nagyBetu[i];
                Console.WriteLine(osszesBetu[i]);
                i++;

            }
            while (i < 52)
            {
                osszesBetu[i] = kisBetu[i - 26];
                Console.WriteLine(osszesBetu[i]);
                i++;


            }

            Console.ReadLine();
            Console.Clear();
            //4.feladat:
            // Hozz létre egy 26 elemű string tömböt betuParok néven.
            // Töltsd föl a következőképpen: a kisBetu tömb 0. eleméhez
            //add hozzá a nagyBetu tomb 0. elemét úgy,
            //hogy egy stringet alkossanak: „Aa”;
            //majd ezt a stringet tedd bele a betuParok tömbbe.
            //Ismételd meg ezt a többi elemmel is.
            Console.WriteLine("4.feladat.");
            string[] betuParok = new string[26];
            i = 0;
            while (i < 26)
            {

                betuParok[i] = Convert.ToString(nagyBetu[i]) + Convert.ToString(kisBetu[i]);

                Console.WriteLine(betuParok[i]);
                i++;
            }


            Console.ReadLine();
            Console.Clear();



            //5.feladat:
            // Hozz létre egy 100 elemű karaktertömböt szazKisBetu néven.
            //Töltsd föl véletlenül kiválasztott kisbetűkkel.


            Console.WriteLine("5.feladat.");
            Random rnd = new Random();
            char[] szazKisBetu = new char[100];
            i = 0;

            while (i < 100)
            {
                Console.Write("{0}. sorszám: ", i + 1);

                szazKisBetu[i] = kisBetu[rnd.Next(0, 26)];
                Console.WriteLine(szazKisBetu[i]);
                i++;

            }



            Console.ReadLine();
            Console.Clear();

            //6.feladat:

            // Hozz létre egy 10 elemű string tömböt, melyben 3 számjegyből álló
            //titkos kódokat fogsz tárolni.
            // Töltsd föl a következőképpen: alakíts stringgé egy véletlen számjegyet,
            //és adj hozzá még kettő ilyet úgy, hogy egy stringet alkossanak. (Pl.: 341, 593)
            Console.WriteLine("6.feladat.");

            string[] szamjegy = new string[10];
            i = 0;
            while (i < 10)
            {

                szamjegy[i] = Convert.ToString(rnd.Next(0, 10)) + Convert.ToString(rnd.Next(0, 10)) + Convert.ToString(rnd.Next(0, 10));
                Console.WriteLine(szamjegy[i]);
                i++;

            }

            Console.ReadLine();
            Console.Clear();


            // INNENTŐL KEZDVE NEM KELL MEGTANULNI MINDENKINEK, CSAK ANNAK, AKI EMELTRE KÉSZÜL.

            //7. feladat:
            //Oldd meg a 6-os feladatot azzal a változtatással,
            //hogy öt hosszú legyen a titkos kód.
            //Az első helyen egy véletlen számjegy álljon,
            //aztán egy véletlen kisbetű, aztán egy véletlen nagybetű,
            //végül egy véletlen kétjegyű szám. (Pl.: 3hZ71)

            Console.WriteLine("7.feladat.");
            string[] szamjegy2 = new string[10];
            i = 0;

            while (i < 10)
            {

                szamjegy2[i] = Convert.ToString(rnd.Next(0, 10)) + kisBetu[rnd.Next(0, 26)] + nagyBetu[rnd.Next(0, 26)] + Convert.ToString(rnd.Next(10, 100));
                Console.WriteLine(szamjegy2[i]);
                i++;

            }

            Console.ReadLine();
            Console.Clear();
            //8. feladat:
            //Készíts 8 hosszú titkos kódot, melyben kisbetű, nagybetű, szám, és egyéb jelek is vannak.
            //Szóköz, ékezetes karakter nem lehet benne. Segítségül használd a 7 bites ASCII táblát.
            //Pl.: fT!jq/d+

            Console.WriteLine("8.feladat.");

            string[] asci = new string[10];
            i = 0;
            while (i < 10)
            {
                asci[i] = Convert.ToString(Convert.ToChar(rnd.Next(33, 126))) + Convert.ToString(Convert.ToChar(rnd.Next(33, 126)))
                        + Convert.ToString(Convert.ToChar(rnd.Next(33, 126))) + Convert.ToString(Convert.ToChar(rnd.Next(33, 126)))
                        + Convert.ToString(Convert.ToChar(rnd.Next(33, 126))) + Convert.ToString(Convert.ToChar(rnd.Next(33, 126)))
                        + Convert.ToString(Convert.ToChar(rnd.Next(33, 126))) + Convert.ToString(Convert.ToChar(rnd.Next(33, 126)));
                Console.WriteLine(asci[i]);
                i++;
            }


            Console.ReadLine();
            Console.Clear();

            Console.WriteLine("8.feladat - 2. verzió");
            string[] ascii = new string[10];
            i = 0;
            int j;
            while (i < 10)
            {
                j = 0;
                while (j < 8)
                {
                    ascii[i] = ascii[i] + Convert.ToString(Convert.ToChar(rnd.Next(33, 126)));
                    j++;
                }
                Console.WriteLine(ascii[i]);
                i++;
            }

            Console.ReadLine();
            Console.Clear();

            //9. feladat:
            //Alkoss a kisBetu tömb elemeiből négybetűs szavakat, melyeket nem kell tárolni, csak kiírni a képernyőre.
            //Minden egyes szó kiírása után kérdezd meg a usert, hogy értelmes-e a szó.
            //Számold meg, hány értelmes szót sikerült alkotni, és az eredményt írd ki a képernyőre.
            Console.WriteLine("9.feladat.");
            i = 0;
            string valasz;
            int q = 0;
            while (i < 10)
            {


                Console.Write(kisBetu[rnd.Next(0, 26)]);
                Console.Write(kisBetu[rnd.Next(0, 26)]);
                Console.Write(kisBetu[rnd.Next(0, 26)]);
                Console.WriteLine(kisBetu[rnd.Next(0, 26)]);
                i++;
                Console.Write("Értelmes szó ez? (i/n): ");
                valasz = Console.ReadLine();

                if (valasz == "i")
                {
                    q++;
                }
            }

            Console.WriteLine("Értelmes szavak száma : {0}", q);
            Console.ReadLine();
            Console.Clear();

            Console.WriteLine("9.feladat. - 2. verzió");
            i = 0;
            q = 0;
            while (i < 10)
            {
                j = 0;
                while (j < 4)
                {
                    Console.Write(kisBetu[rnd.Next(0, 26)]);
                    j++;
                }
                Console.WriteLine();
                i++;
                Console.Write("Értelmes szó ez? (i/n): ");
                valasz = Console.ReadLine();

                if (valasz == "i")
                {
                    q++;
                }
            }

            Console.WriteLine("Értelmes szavak száma : {0}", q);
            Console.ReadLine();
        }
    }
}