*euForia*

2021.09.29. Számonkérés

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.17. Házi feladat ellenőrzése

Jeleztem, hogy lesz házi feladat, de mégsem lesz.

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(-10, 11);
        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(1, 38), rnd.Next(1, 32768));
        Console.Beep(rnd.Next(1, 38), rnd.Next(1, 32768));
        Console.Beep(rnd.Next(1, 38), rnd.Next(1, 32768));
        Console.Beep(rnd.Next(1, 38), rnd.Next(1, 32768));
        Console.Beep(rnd.Next(1, 38), rnd.Next(1, 32768));
        Thread.Sleep(rnd.Next(1, 5001));
      }

      for (int i = 0; i < 10; i++)
      {
        for (int j = 0; j < 5; j++)
        { 
          Console.Beep(rnd.Next(1, 38), rnd.Next(1, 32768));
        }
        Thread.Sleep(rnd.Next(1, 5001));
      }
      //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.