2021.09.22. - 27. For ciklus gyakorlás, foreach, összegzés tétele

Házi feladat a 9.-ig megoldani.

Ezt elkezdtük, nincs házi.

 Foreach-összegzés tétele

//1.Feladat:

//Töltsünk fel véletlenszámból képzett sorozattal

//egy 100 elemű tömböt a következő módon:

//Egy valódi kicsi véletlenszámot szorozzunk meg 2 négyzetgyökével,

//ez legyen az első szám.

//A keletkezett számot minden ciklusmagban növeljük meg

//hárommal, ezzel töltsük fel a többi tömbelemet.

 

//2. feladat:

//Hozz létre egy új 100 elemű tömböt egész számoknak.

//Ebbe az eredeti tömb számjegyeinek egész részei

//fognak kerülni.

 

int[] egeszSzamok = new int[100];

for (int i = 0; i < egeszSzamok.Length; i++)

{

    //egeszSzamok[0] = szamok[0]; ez nem működik

    egeszSzamok[i] = (int)szamok[i];

    //típuskényszerítés: egész számmá alakítjuk a törtet,

    //közben elveszik a tizedespont utáni rész,

    //most éppen ez a cél

    Console.WriteLine("Az új tömb {0}. eleme: {1}", i + 1, egeszSzamok[i]);

}

Console.ReadLine();

 

//3. feladat:

//Írjuk ki a tömb tartalmát a foreach ciklussal!

//x:ciklusváltozó, értéke automatikusan lépésenként 1-gyel nő,

//a típusát meg kell adni, egyezzen a tömbelemek típusával

//in kulcsszó után kell megadni a tömb nevét

//Minden tömbelemet ki tudunk olvasni,

//de megváltoztatni nem tudjuk.

 

//4. feladat:

//Írjuk ki a tömb tartalmát visszafelé!

//(Utolsó elemtől az elsőig, egyesével visszafelé lépkedve.)

 

//Összegzés tétele:

//Egy tömbben, vagy sorozatban határozd meg

//adott tulajdonságú elemek összegét.

//5. feladat:

//Határozd meg a tömbelemek összegét!

 

 

//6. feladat:

//Összegzés tétele:határozd meg a páros tömbelemek összegét!

 

//7. feladat:

//Összegzés tétele:határozd meg a páratlan tömbelemek összegét!

 

//8. feladat:

//Összegzés tétele:határozd meg a 50-nel osztható

//tömbelemek szorzatát!

 

//9. feladat:

//Írjunk ki 50 számot a képernyőre 100-zal kezdődően kettesével!

 

//10. feladat:

//Írjunk ki 50 egymást követő számot 1000-től

//kezdődően visszafelé!

//11. feladat:

//Írjunk ki a képernyőre sorfolytonosan (szóközzel elválasztva)

//10 db számot,amelyek közül az első az 1, és minden

//rákövetkező a duplája.

 

//12. feladat:

//Írjunk ki a képernyőre egy 10 elemű sorozatot,

//melynek első tagja -10000, minden következő tag

//az előző -0.5-szerese.


Megoldás:

namespace rogzitettLepesszamuCiklusok
{
    class Program
    {
        static void Main(string[] args)
        {
            //1.Feladat:
            //Töltsünk fel véletlenszámból képzett sorozattal
            //egy 100 elemű tömböt a következő módon:
            //Egy valódi kicsi véletlenszámot szorozzunk meg 2 négyzetgyökével,
            //ez legyen az első szám.
            //A keletkezett számot minden ciklusmagban növeljük meg 
            //hárommal, ezzel töltsük fel a többi tömbelemet.
            //Írjunk ki minden tömbelemet ugyanabban a ciklusban.

            double[] szamok = new double[100];
            Random rnd = new Random();
            double a = rnd.Next(10) * Math.Sqrt(2);
            for (int i = 0; i < szamok.Length; i++)
            {
                szamok[i] = a;
                Console.WriteLine(szamok[i]);
                a = a + 3;
            }
            Console.ReadLine();

            //2. feladat:
            //Hozz létre egy új 100 elemű tömböt egész számoknak.
            //Ebbe az eredeti tömb számjegyeinek egész részei
            //fognak kerülni.
            int[] egeszSzamok = new int[100];
            for (int i = 0; i < egeszSzamok.Length; i++)
            {
                //egeszSzamok[0] = szamok[0]; ez nem működik
                egeszSzamok[i] = (int)szamok[i];
                //típuskényszerítés: egész számmá alakítjuk a törtet,
                //közben elveszik a tizedespont utáni rész,
                //most éppen ez a cél
                Console.WriteLine("Az új tömb {0}. eleme: {1}", i + 1, egeszSzamok[i]);
            }
            Console.ReadLine();

            //3. feladat:
      //Írjuk ki a tömb tartalmát a foreach ciklussal!
      //x: az adott tömbelem, mindig az aktuális
      //a típusát meg kell adni, egyezzen a tömbelemek típusával - a var kulcsszó bármilyen típusnak megfelel
      //in kulcsszó után kell megadni a tömb nevét
      //Minden tömbelemet ki tudunk olvasni,
      //de megváltoztatni nem tudjuk.            foreach (int x in egeszSzamok)
            {
                Console.WriteLine(x);
            }
            Console.ReadLine();

            //4. feladat:
            //Írjuk ki a tömb tartalmát visszafelé!
            //(Utolsó elemtől az elsőig, egyesével visszafelé lépkedve.)
            for (int i = egeszSzamok.Length - 1; i >= 0; i--)
            {
                Console.WriteLine("Az új tömb {0}. eleme: {1}", i + 1, egeszSzamok[i]);
            }

            //5. feladat:
            //Összegzés tétele: határozd meg a tömbelemek összegét!
            int osszeg = 0;

            for (int i = 0; i < egeszSzamok.Length; i++)
            {
                osszeg = osszeg + egeszSzamok[i];
            }
            Console.WriteLine("A tömbelemek összege: {0}", osszeg);
            Console.ReadLine();

            //6. feladat:
            //Összegzés tétele:határozd meg a páros tömbelemek összegét!
            int parosOsszeg = 0;
            for (int i = 0; i < egeszSzamok.Length; i++)
            {
                if (egeszSzamok[i] % 2 == 0)
                    parosOsszeg = parosOsszeg + egeszSzamok[i];
            }
            Console.WriteLine("A páros elemek összege: {0}", parosOsszeg);
            Console.ReadLine();

            //7. feladat:
            //Összegzés tétele:határozd meg a páratlan tömbelemek összegét!
            int paratlanOsszeg = 0;
            for (int i = 0; i < egeszSzamok.Length; i++)
            {
                if (egeszSzamok[i] % 2 != 0)
                    paratlanOsszeg = paratlanOsszeg + egeszSzamok[i];
            }
            Console.WriteLine("A páratlan elemek összege: {0}", paratlanOsszeg);
            Console.ReadLine();

            //8. feladat:
            //Összegzés tétele:határozd meg a 50-nel osztható tömbelemek szorzatát!
            int szorzat = 1;
            for (int i = 0; i < egeszSzamok.Length; i++)
            {
                if (egeszSzamok[i] % 50 == 0)
                    szorzat = szorzat * egeszSzamok[i];
            }
            Console.WriteLine("Az 50-nel osztható elemek szorzata: {0}", szorzat);
            Console.ReadLine();

            //9. feladat:
            //Írjunk ki 50 számot a képernyőre 100-zal kezdődően kettesével!
            int szam = 100;
            for (int i = 0; i < 50; i++)
            {
                Console.WriteLine(szam);
                szam = szam + 2;
            }
            Console.ReadLine();

            //10. feladat:
            //Írjunk ki 50 egymást követő számot 1000-től kezdődően visszafelé!
            szam = 1000;
            for (int i = 0; i < 50; i++)
            {
                Console.WriteLine(szam);
                szam--;
            }
            Console.ReadLine();

            //11. feladat:
            //Írjunk ki a képernyőre sorfolytonosan (szóközzel elválasztva)
            //10 db számot,amelyek közül az első az 1, és minden
            //rákövetkező a duplája.
            int b = 1;
            for (int i = 0; i < 10; i++)
            {
                Console.Write("{0} ", b);
                b = b * 2;
            }
            Console.WriteLine();
            Console.ReadLine();

            //12. feladat:
            //Írjunk ki a képernyőre egy 10 elemű sorozatot,
            //melynek első tagja -10000, minden következő tag
            //az előző -0.5-szerese.
            double c = -10000;
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine(c);
                c = c * -0.5;
            }
            Console.ReadLine();
        }
    }
}

2021.09.22. Lépésenkénti futtatás, hibakeresés

A Debug/Windows/Locals ablaknak nyitva kell lenni.

using System;

namespace ConsoleApp9
{
  class Program
  {
    static void Main(string[] args)
    {
      Random rnd = new Random();
      int[] szamok = new int[5];
      Console.WriteLine("CSAK AKKOR ÍRJA KI, HA AKAROM...");
      for (int i = 0; i < szamok.Length; i++)
      {
        szamok[i] = rnd.Next();
        Console.WriteLine(szamok[i]);
      }
      Console.ReadLine();
    }
  }
}






2021.09.20. For ciklus gyakorlás 3


Nincs házi feladat. Köv. órán bemásoljuk a mai munkát a digifüzetbe.



 1. feladat:

Töltsünk föl egy tömböt véletlen számokkal! Együtt fogjuk kipróbálni ennek 6-féle módját.

2. feladat:

        Tölts föl egy 1000 elemű tömböt véletlen számokkal!

        A végén legyen egy beep!

3. feladat:

        Tölts föl egy százezer elemű tömböt véletlen számokkal!

        A végén legyen egy beep!

4. feladat:

        Tölts föl egy egymillió elemű tömböt véletlen számokkal!

        A végén legyen egy beep!

5. feladat:

        Tölts föl egy 100 elemű tömböt véletlen számokkal, de úgy,  hogy minden egyes értékadásnál írd is ki az értéket a képernyőre!

6. feladat:

        Szólaltasd meg 10-szer a hangszórót, a hangok között fél másodperc késleltetéssel!

7. feladat:

         Állítsd be a háttérszínt kékre, töröld át vele a képernyőt!

         Állíts be fél másodperc várakozást!

         Állítsd be a háttérszínt zöldre, töröld át vele a képernyőt!

         Állíts be egy tized másodperc várakozást!

         A fenti műveleteket összesen 20-szor végezd el!

8. feladat:

        Állítsd át a betű-, és háttérszínt a kedvencedre.

        Írd ki a képernyőre 1000-szer közvetlenül egymás után, hogy utálod a ... [itt behelyettesíthetsz valamit]. (Nem bármit:)

        Állítsd át a betű-, és háttérszínt valami másra.

        Írd ki a képernyőre 1000-szer közvetlenül egymás után, hogy szereted a ... [itt behelyettesíthetsz valamit]. (Nem bármit:)

9. feladat:

Találj ki egy hasonló ciklusos feladatot, és írd meg :)


2021.09.15. For ciklus 2. gyakorló feladat

 Házi feladat

        //1.feladat:

        //Definiálj egy 5 elemű, egész számokból álló tömböt.

        //Töltsd föl programból -10 és 10 közötti számokkal.

        //Add össze a negatív tömbelemeket for ciklussal!

        //2.feladat:

        //Kérj be a felhasználótól 5 karaktert egy tömbbe (ciklussal).

        //Ciklussal  írasd ki a kék hátterű képernyőre zöld színnel

        //            a betűket úgy, mintha egy szó lenne.

        //3.feladat:

        //Szólaltasd meg Artu Ditut. Írj egy ciklust,

        //ami kedved szerinti számban ismétel 5 véletlen hangmagasságú

        //és hosszúságú hangból álló hangsorokat,

        //plusz egy véletlen hosszúságú szünetet.

        //    Tehát a ciklusmagban legyen 5 hang, és egy szünet;

        //ezt ismételje  a ciklus akárhányszor.

        //    (A Beep() első paramétere 37 és 32767 közötti számokat tud „megszólaltatni”.)

        //A hang időtartamát is vedd véletlenre, ezredmásodpercben kell neki megadni.

Milán megoldása alapján:



using System;
using System.Threading;

namespace hazi_2021._09._15
{
  class Program
  {
    static void Main(string[] args)
    {
      //1.feladat:

      //Definiálj egy 5 elemű, egész számokból álló tömböt.
      int minus = 0;
      //Töltsd föl programból -10 és 10 közötti számokkal.
      int[] szamok = new int[5];
      Random rnd = new Random();
      for (int i = 0; i < szamok.Length; i++)
      {
        szamok[i] = rnd.Next(-1011);
        if (0 > szamok[i])
        {
          minus = minus + szamok[i];
        }
      }
      //Add össze a negatív tömbelemeket for ciklussal!

      //2.feladat:
      char[] kar = new char[5];

      //Kérj be a felhasználótól 5 karaktert egy tömbbe (ciklussal).
      Console.WriteLine("Irjon be 5 karaktert");
      //Ciklussal  írasd ki a kék hátterű képernyőre zöld színnel
      for (int i = 0; i < kar.Length; i++)
      {
        Console.Write("{0}. karakter:", i+1);
        kar[i] = Convert.ToChar(Console.ReadLine());

      }
      Console.BackgroundColor = ConsoleColor.Blue;
      Console.ForegroundColor = ConsoleColor.Green;
      Console.Clear();

      //            a betűket úgy, mintha egy szó lenne.
      for (int i = 0; i < kar.Length; i++)
      {
        Console.Write(kar[i]);
      }
      //3.feladat:
      for (int i = 0; i < 10; i++)
      {
        Console.Beep(rnd.Next(138), rnd.Next(132768));
        Console.Beep(rnd.Next(138), rnd.Next(132768));
        Console.Beep(rnd.Next(138), rnd.Next(132768));
        Console.Beep(rnd.Next(138), rnd.Next(132768));
        Console.Beep(rnd.Next(138), rnd.Next(132768));
        Thread.Sleep(rnd.Next(15001));
      }

      for (int i = 0; i < 10; i++)
      {
        for (int j = 0; j < 5; j++)
        { 
          Console.Beep(rnd.Next(138), rnd.Next(132768));
        }
        Thread.Sleep(rnd.Next(15001));
      }
      //Szólaltasd meg Artu Ditut. Írj egy ciklust,

      //ami kedved szerinti számban ismétel 5 véletlen hangmagasságú

      //és hosszúságú hangból álló hangsorokat,

      //plusz egy véletlen hosszúságú szünetet.

      //    Tehát a ciklusmagban legyen 5 hang, és egy szünet;

      //ezt ismételje  a ciklus akárhányszor.

      //    (A Beep() első paramétere 37 és 32767 közötti számokat tud „megszólaltatni”.)

      //A hang időtartamát is vedd véletlenre, ezredmásodpercben kell neki megadni.
      Console.ReadLine();

    }
  }
}


2021.09.15. For ciklus – 1. gyakorló feladat

 

For ciklus – 1. gyakorló feladat

            //1. feladat:

            //Egy 100 elemű tömböt töltsünk fel véletlen egész számokkal.

            //Feltöltés közben írjuk ki, milyen szám kerül a tömbbe éppen.

            //Feltöltés után számoljuk meg, hány darab páros,

            //és hány darab páratlan szám van benne.

 

            //2. feladat:

            //Egy 1000 elemű tömböt töltsünk fel véletlen tört számokkal.

            //Ne adjunk meg értékhatárt.

            //Feltöltés közben folyamatosan összesítsük a számokat,

            //majd a ciklus lefutása után adjuk meg a számok átlagát.

            //Segítség:

            //Próbáljuk meg ezzel a két módszerrel megoldani a feladatot.

            //ezt már ismerjük:

            //Convert.ToDouble(rnd.Next());

            //ez egy 0 és 1 közötti véletlen tört számot ad:

            //rnd.NextDouble();

 

            //3. feladat:

            //Egy 33 elemű tömböt töltsünk fel félévi programozás jegyekkel.

            //Ezt véletlenszámokkal oldjuk meg.

            //Ugyanazon cikluson belüli többágú szelekció alkalmazásával számoljuk meg,

            //melyik jegyből hány darab van, végül írjuk ki az eredményt.

2021.09.10.-13. For ciklus bevezetés

 Nem kell otthon befejezni. Házi feladat az eddigi új anyag tanulása. 

(Már két órán keresztül ezzel foglalkoztunk, legközelebb már ellenőrzéssel kezdünk.)

For ciklus bevezetés

namespace forCiklusBevezetese

{

    class Program

    {

        static void Main(string[] args)

        {

            // Ciklusok bevezetés – a FOR ciklus

            // Feladat: Hozzunk létre egy 10 elemű tömböt egész számok tárolására.

            // Töltsük föl véletlen számokkal.

            // Írjuk ki a képernyőre soronként a számokat.

 

            int[] tomb = new int[10];

            Random rnd = new Random();

 

            tomb[0] = rnd.Next();

            tomb[1] = rnd.Next();

            tomb[2] = rnd.Next();

            tomb[3] = rnd.Next();

            tomb[4] = rnd.Next();

            tomb[5] = rnd.Next();

            tomb[6] = rnd.Next();

            tomb[7] = rnd.Next();

            tomb[8] = rnd.Next();

            tomb[9] = rnd.Next();

            Console.WriteLine("A 10 elemű tömb aktuális elemeinek kiírása hagyományosan:");

            Console.WriteLine(tomb[0]);

            Console.WriteLine(tomb[1]);

            Console.WriteLine(tomb[2]);

            Console.WriteLine(tomb[3]);

            Console.WriteLine(tomb[4]);

            Console.WriteLine(tomb[5]);

            Console.WriteLine(tomb[6]);

            Console.WriteLine(tomb[7]);

            Console.WriteLine(tomb[8]);

            Console.WriteLine(tomb[9]);

 

            Console.ReadLine();

 

            //Végezzük el ezt a feladatot egy 1000 elemű tömbbel!

            //?????????

            //Megoldás: a ciklus.

            //A ciklusok közül elsőként a for ciklust tanuljuk.

 

            // A fenti tömb feltöltése:

 

            for (int i = 0; i < tomb.Length; i++)

            {

                tomb[i] = rnd.Next();

            }

 

            //A fenti tömb elemeinek kiírása:

            Console.WriteLine("A 10 elemű tömb aktuális elemeinek kiírása ciklussal:");

            for (int i = 0; i < tomb.Length; i++)

            {

                Console.WriteLine(tomb[i]);

            }

 

            Console.ReadLine();

 

            //for               kulcsszó

            //i                 ciklusváltozó

            //i<tomb.Length     kilépési feltétel

            //i++               a ciklusváltozó növelése 1-gyel

            //ciklusmag         a {} közötti terület, ide több utasítást is lehet írni



            //1. feladat:

            //Töltsünk fel egy 5000 elemű tömböt véletlen valós számokkal.

            //Írjuk ki a képernyőre ezeket a számokat is.

            //Minden szám előtt legyen ott a tömb indexe.

 

 

            //2. feladat:

            //Töltsünk fel egy 10 elemű tömböt igaz-hamis értékekkel,

            //amelyeket a felhasználótól kérünk be.

            //Írjuk ki ezeket is a képernyőre.

 

 

            //3. feladat:

            //A 2-es feladat kiírását ismételjük meg úgy, hogy a képernyőre

            //magyarul írjuk ki igaz/hamis formában a tartalmat.

           

 

            //4. feladat:

            //Töltsünk fel egy 5 elemű tömböt egy mondat szavaival,

            //amelyeket a felhasználótól kérünk be.

            //Írjuk ki a szavakat mondatként!

 

           

            //5. feladat:

            //Töltsünk fel egy 20 elemű tömböt betűkkel,

            //amelyeket a felhasználótól kérünk be.

            //Írassuk ki a betűket egy szóként a képernyőre.

 

 

            //6. feladat:

            //Töltsünk fel egy tetszőleges hosszúságú

            //byte tömböt véletlen számokkal.

            //Írjuk ki a képernyőre ezeket a számokat is.

 

 

            //7. feladat:

            //Írjuk ki a tömb minden elemét az utolsótól

            //az elsőig, egyesével visszafelé haladva.

            //Figyeljük meg a ciklusváltozó, és a feltétel

            //kezelését.


Egy lehetséges megoldás Elemértől:

using System;

namespace forCiklusBevezetese

{

  class Program

  {

    static void Main(string[] args)

    {


      //1. feladat:

      //Töltsünk fel egy 5000 elemű tömböt véletlen valós számokkal.

      //Írjuk ki a képernyőre ezeket a számokat is.

      //Minden szám előtt legyen ott a tömb indexe.
      double[] otEzer = new double[5000];
      Random rnd = new Random();
      for (int i = 0; i < otEzer.Length; i++)
      {
        otEzer[i] = rnd.Next();
        Console.WriteLine("{0}. {1}", i+1, otEzer[i]);
      }


      Console.WriteLine();

      //2. feladat:

      //Töltsünk fel egy 10 elemű tömböt igaz-hamis értékekkel,

      //amelyeket a felhasználótól kérünk be.

      //Írjuk ki ezeket is a képernyőre.
      bool[] _bool = new bool[10];
      for (int i = 0; i < _bool.Length; i++)
      {
        Console.Write("Igaz vagy hamis? (true/false): ");
        _bool[i] = Convert.ToBoolean(Console.ReadLine());
        Console.WriteLine(_bool[i]);
      }



      Console.WriteLine();
      //3. feladat:

      //A 2-es feladat kiírását ismételjük meg úgy, hogy a képernyőre

      //magyarul írjuk ki igaz/hamis formában a tartalmat.

      for (int i = 0; i < _bool.Length; i++)
      {
        if (_bool[i] == false)
        {
          Console.WriteLine("Hamis");
        }
        else
        {
          Console.WriteLine("Igaz");
        }
      }


      Console.WriteLine();
      //4. feladat:

      //Töltsünk fel egy 5 elemű tömböt egy mondat szavaival,

      //amelyeket a felhasználótól kérünk be.

      //Írjuk ki a szavakat mondatként!
      string[] szo = new string[5];
      for (int i = 0; i < szo.Length; i++)
      {
        Console.Write("Írjon be egy szót: ");
        szo[i] = Console.ReadLine();
      }
      for (int i = 0; i < szo.Length; i++)
      {
        Console.Write("{0} ", szo[i]);
      }


      Console.WriteLine();

      //5. feladat:

      //Töltsünk fel egy 20 elemű tömböt betűkkel,

      //amelyeket a felhasználótól kérünk be.

      //Írassuk ki a betűket egy szóként a képernyőre.

      char[] betu = new char[20];
      for (int i = 0; i < betu.Length; i++)
      {
        Console.Write("Írjon be egy betűt: ");
        betu[i] = Convert.ToChar(Console.ReadLine());
      }
      for (int i = 0; i < betu.Length; i++)
      {
        Console.Write(betu[i]);
      }


      Console.WriteLine();
      //6. feladat:

      //Töltsünk fel egy tetszőleges hosszúságú

      //byte tömböt véletlen számokkal.

      //Írjuk ki a képernyőre ezeket a számokat is.

      byte[] _random = new byte[7];
      for (int i = 0; i < _random.Length; i++)
      {
        _random[i] = Convert.ToByte(rnd.Next(256));  //rnd.Next(0,256)
      }


      Console.WriteLine();
      //7. feladat:

      //Írjuk ki a tömb minden elemét az utolsótól

      //az elsőig, egyesével visszafelé haladva.

      //Figyeljük meg a ciklusváltozó, és a feltétel

      //kezelését.


      for (int i = 6; i >= 0; i--)
      {
        Console.WriteLine(_random[i]);
      }

      Console.ReadLine();
    }
  }
}

2023.04.26. Javító feladatsor