2023. október 13., péntek

2023.10.13. Employee hagyományos megoldás

  Az Employee feladat nem LINQ-s, hagyományos megoldása

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

namespace Employee
{
    class Dolgozok
    {
        //name, age, city, department, position, gender, marital status, salary (EUR)
        public string Nev { get; set; }
        public int Eletkor { get; set; }
        public string Varos { get; set; }
        public string Osztaly { get; set; }
        public string Pozicio { get; set; }
        public string Nem { get; set; }
        public string CsaladiAllapot { get; set; }
        public double Fizetes { get; set; }


        public Dolgozok(string sor)
        {
            var v = sor.Split(';');
            Nev = v[0];
            Eletkor = int.Parse(v[1]);
            Varos = v[2];
            Osztaly = v[3];
            Pozicio = v[4];
            Nem = v[5];
            CsaladiAllapot = v[6];
            Fizetes = Convert.ToDouble(v[7]);
        }

        public double EvesFizetesForintban()
        {
            return Fizetes * 12 * 390;
        }

        //Készíts egy osztályon belüli virtuális metódust az adatok kiírására.
        public override string ToString()
        {
            return $"{Nev}; {Eletkor}; {Varos}; {Osztaly}; {Pozicio}; {Nem}; {CsaladiAllapot}; {Fizetes}";
        }
    }
}


using System;
using System.IO;
using System.Collections.Generic;
namespace Employee
{
    class Program
    {
        //A következő feladatokat a program osztályban elhelyezett statikus metódusokkal oldd meg. (Aki szeret kísérletezni, teheti ezeket a metódusokat egy újabb osztályba.) Egyes feladatokat meg lehet oldani LINQ-val is, de ha belefér az időbe, kódoljátok le hagyományosan is.Ha van olyan feladat, ami nem egyértelmű, pl.az, hogyan kell kiírni, ott rád van bízva a megoldás.
        //Függvény segítségével írd ki az életkorok átlagát.
        #region statikus metódusok
        static double atlagEletkor(List<Dolgozok> k)
        {
            double osszegEletkor = 0;
            for (int i = 0; i < k.Count; i++)
            {
                osszegEletkor = osszegEletkor + k[i].Eletkor;
            }
            return osszegEletkor / k.Count;
        }
        //Függvény segítségével írd ki azon személyek számát, akiknek a városa 'Budapest'.
        static int szemelyekBp(List<Dolgozok> k)
        {
            int db = 0;
            for (int i = 0; i < k.Count; i++)
            {
                if (k[i].Varos == "Budapest")
                {
                    db++;
                }
            }
            return db;
        }
        //Függvény segítségével keresd ki, majd a virtuális metódus segítségével írd ki a legidősebb személy adatait.
        //Ez a megoldás nem függvénnyel készült.
        static void legidosebbSzemely(List<Dolgozok> k)
        {
            int legidosebbEletkor = k[0].Eletkor;
            for (int i = 1; i < k.Count; i++)
            {
                if (k[i].Eletkor > legidosebbEletkor)
                {
                    legidosebbEletkor = k[i].Eletkor;
                }
            }            
            for (int i = 0; i < k.Count; i++)
            {
                if (k[i].Eletkor == legidosebbEletkor)
                {
                    Console.WriteLine(k[i]);
                }
            }
        }

        //Függvény segítségével keresd ki, majd a virtuális metódus segítségével írd ki a legidősebb személy adatait.
        //Ez a megoldás függvénnyel készült.
        static Dolgozok legidosebbSzemely1(List<Dolgozok> k)
        {
            Dolgozok legidosebb = k[0];
            for (int i = 1; i < k.Count; i++)
            {
                if (k[i].Eletkor > legidosebb.Eletkor)
                {
                    legidosebb = k[i];
                }
            }
            return legidosebb;
        }
        //Függvény segítségével döntsd el, majd a főprogramban írd ki, hogy van - e 30 év fölötti személy, és emellett írd ki a nevét is. (Ez a függvény tehát két értéket kell, hogy generáljon, ezt egyetlen szövegként add vissza a főprogramnak, és a főprogram bontsa szét az adatokat, majd utána írja ki.)
        static string harmincFeletti(List<Dolgozok> k)
        {
            bool van = false;
            int i = 0;
            while (i < k.Count)
            {
                if (k[i].Eletkor > 30)
                {
                    van = true;
                }
                i++;
            }

            if (van)
            {
                return $"{"true"} {k[i - 1].Nev}";
            }
            else
            {
                return $"{"false"} {"nincs"}";
            }
        }
        //Függvénnyel válogasd ki azon személyek nevét egy új tömbbe (nem listába), akik 30 évnél fiatalabbak. Ennek a tömbnek a hasznos tartalmát írd ki a főprogramban.
        static string[] harmincAlatt(List<Dolgozok> k)
        {
            int x = 0;
            for (int i = 0; i < k.Count; i++)
            {
                if (k[i].Eletkor < 30)
                {
                    x++;
                }
            }
            string[] harmincAlattTomb = new string[x];
            int j = 0;
            for (int i = 0; i < k.Count; i++)
            {
                if (k[i].Eletkor < 30)
                {
                    harmincAlattTomb[j] = k[i].Nev;
                    j++;
                }
            }
            return harmincAlattTomb;
        }
        //Egyetlen függvénnyel keresd meg a legfiatalabb és a legidősebb személyt. A függvénynek legyen két olyan paramétere, amiben az eredményt vissza lehet juttatni a főprogramba, és ott ki lehet írni a nevüket és a korukat. A függvény visszatérési értéke pedig képes legyen azt jelezni, hogy van-e több ugyanolyan korú legfiatalabb személy.
        static bool legidosebbEsLegfiatalabbSzemely(List<Dolgozok> k, out string legidosebbNev, out string legfiatalabbNev)
        {
            int legidosebbEletkor = k[0].Eletkor;
            legidosebbNev = k[0].Nev;
            int szamlalo1 = 0;
            for (int i = 1; i < k.Count; i++)
            {
                if (k[i].Eletkor > legidosebbEletkor)
                {
                    legidosebbEletkor = k[i].Eletkor;
                    legidosebbNev = k[i].Nev;
                }
            }
            for (int i = 0; i < k.Count; i++)
            {
                if (k[i].Eletkor == legidosebbEletkor) szamlalo1++;
            }

            int legfiatalabbEletkor = k[0].Eletkor;
            legfiatalabbNev = k[0].Nev;
            int szamlalo2 = 0;
            for (int j = 1; j < k.Count; j++)
            {
                if (k[j].Eletkor < legfiatalabbEletkor)
                {
                    legfiatalabbEletkor = k[j].Eletkor;
                    legfiatalabbNev = k[j].Nev;
                    szamlalo2++;
                }
            }
            for (int i = 0; i < k.Count; i++)
            {
                if (k[i].Eletkor == legfiatalabbEletkor) szamlalo2++;
            }
            //a legutolsó legidősebbet és a legutolsó legfiatalabbat adja meg
            //ez is jó:
            //if (szamlalo1 > 0 || szamlalo2 > 0)
            //{
            //    return true;
            //}
            //else
            //{
            //    return false;
            //}
            //de ez még szebb:
            return szamlalo1 > 0 || szamlalo2 > 0 ? true : false;
        }
        //Készíts egy függvényt, ami átszámolja az euróban megadott havi fizetést éves fizetéssé, és az eredményt még váltsd át magyar forintba is.
        //ez az osztályban van

        //Készíts egy függvényt, amelynek visszatérési értéke egy objektumokat tartalmazó lista, amelyben szerepel az 5 millió forint éves fizetés feletti munkavállalók neve és az éves fizetésük forintban. (Az átszámításhoz használd az előző feladat függvényét.)  Az elkészült listát a főprogram írja ki egy új fájlba(a virtuális metódus segítségével).
        //itt folytatjuk
        static List<string> FajlbaIras(List<Dolgozok> k)
        {
            List<string> evesForint = new List<string>();
            foreach (var item in k)
            {
                if (item.EvesFizetesForintban() > 5000000)
                {
                    evesForint.Add($"Név: {item.Nev} Éves fizetés forintban: {item.EvesFizetesForintban()}");
                }
            }
            return evesForint;
        }
        //Írj egy függvényt, aminek a paramétere az eredeti adatokat tartalmazó listának megfelelő típusú. Ennek segítségével számold ki az összes alkalmazott átlagfizetését.
        static double atlag(List<Dolgozok> k)
        {
            double osszeg = 0;
            for (int i = 0; i < k.Count; i++)
            {
                osszeg = osszeg + k[i].Fizetes;
            }
            return Math.Round (osszeg / k.Count, 2);
        }
        #endregion
        static void Main(string[] args)
        {
            //Az osztály segítségével hozz létre egy listát, amely objektumpéldányokat tartalmaz a forrásfájlból beolvasott adatokkal.
            var dolgozok = new List<Dolgozok>();
            foreach (var i in File.ReadAllLines(@"../../src/employee.txt"))
            {
                if (i != "")
                {
                    dolgozok.Add(new Dolgozok(i));
                }
            }
            //A virtuális metódus segítségével írd ki az összes adatot.
            Console.WriteLine("7.feladat");
            Console.WriteLine();
            foreach (var item in dolgozok)
            {
                Console.WriteLine(item);
            }
            //Propertyk kidolgozása(Szorgalmi feladat)
            //Dolgozd ki a property-ket is, és használd őket az adatokhoz való korrekt hozzáférésre és módosításra.
            //Hibakezelés(Szorgalmi feladat)
            //Implementálj hibakezelést az alkalmazásban, például az adatok beolvasásakor vagy a fájlba írás során.      
            Console.WriteLine();
            Console.WriteLine("8.feladat");
            Console.WriteLine();
            Console.WriteLine($"Az átlagéletkor: {atlagEletkor(dolgozok):0.00}");
            Console.WriteLine();
            Console.WriteLine("9.feladat");
            Console.WriteLine();
            Console.WriteLine($"Budapesti lakosok száma: {szemelyekBp(dolgozok)}");
            Console.WriteLine();
            Console.WriteLine("10.feladat 1. megoldás");
            Console.WriteLine();
            legidosebbSzemely(dolgozok);
            Console.WriteLine();
            Console.WriteLine("10.feladat 2. megoldás");
            Console.WriteLine();
            Dolgozok legidosebbDolgozo = legidosebbSzemely1(dolgozok);
            for (int i = 0; i < dolgozok.Count; i++)
            {
                if (dolgozok[i].Eletkor == legidosebbDolgozo.Eletkor)
                {
                    Console.WriteLine(dolgozok[i]);
                }
            }
            Console.WriteLine();
            Console.WriteLine("11.feladat");
            Console.WriteLine();
            var valasz = harmincFeletti(dolgozok).Split(' ');
            if (valasz[0] =="true")
            {
                Console.WriteLine($"Van 30 év feletti személy, az elsőnek a neve: {valasz[1]}");
            }
            else
            {
                Console.WriteLine($"Nincs 30 év feletti személy. ");
            }
            Console.WriteLine();
            Console.WriteLine("12.feladat");
            Console.WriteLine();
            foreach (var item in harmincAlatt(dolgozok))
            {
                Console.WriteLine(item);
            }          
            Console.WriteLine();
            Console.WriteLine("13.feladat");
            Console.WriteLine();
            string legidosebb, legfiatalabb;
            legidosebbEsLegfiatalabbSzemely(dolgozok, out legidosebb, out legfiatalabb);
            Console.WriteLine($"Utolsó legidősebb: {legidosebb}, utolsó legfiatalabb: {legfiatalabb}");
            Console.WriteLine();
            Console.WriteLine("14.feladat");
            Console.WriteLine();
            Console.WriteLine("Kész");
            Console.WriteLine();
            Console.WriteLine("15.feladat Fájlba írás");
            Console.WriteLine();
            using (var sw = new StreamWriter(@"../../src/otmillio.txt"))
            {
                foreach (var item in FajlbaIras(dolgozok))
                {
                    sw.WriteLine(item);
                }
            }
            Console.WriteLine("Kész.");
            Console.WriteLine();
            Console.WriteLine("16.feladat");
            Console.WriteLine();
            Console.WriteLine($"Az átlag havi fizetés: {atlag(dolgozok)} Euró.");
            //Készíts a főprogramban egy olyan listát, amiben csak a developer beosztásúak találhatók, minden tulajdonságukkal. Hívd meg újra a főprogramból az előző függvényt, de most ez az új lista legyen a paramétere. A főprogram írja ki a developerek átlagfizetését.

            Console.WriteLine();
            Console.WriteLine("17.feladat");
            Console.WriteLine();
            var developerLista = new List<Dolgozok>();  
            for (int i = 0; i < dolgozok.Count; i++)
            {
                if (dolgozok[i].Pozicio == "Developer")
                {
                    developerLista.Add(dolgozok[i]);
                }
            }
            Console.WriteLine($"A developerek átlagfizetése: {atlag(developerLista)} Euró");
            Console.WriteLine();
            Console.WriteLine("18.feladat");
            Console.WriteLine();
            //Számold ki a férfi és női alkalmazottak átlagfizetését tetszőleges módszerrel.
            var FerfiAtlag = new List<Dolgozok>();
            var NoiAtlag = new List<Dolgozok>();
            for (int i = 0; i < dolgozok.Count; i++)
            {
                if (dolgozok[i].Nem == "Male")
                {
                    FerfiAtlag.Add(dolgozok[i]);
                }
                else if (dolgozok[i].Nem == "Female")
                {
                    NoiAtlag.Add(dolgozok[i]);
                }
            }
            Console.WriteLine($"A férfiak átlagfizetése: {atlag(FerfiAtlag)} Euró");
            Console.WriteLine();
            Console.WriteLine($"A nők átlagfizetése: {atlag(NoiAtlag)} Euró");
            Console.ReadLine();
        }
    }
}



John;25;Budapest;IT;Engineer;Male;Single;1200

Alice;30;Debrecen;Marketing;Manager;Female;Married;900

Bob;22;Szeged;HR;Assistant;Male;Single;650

Eva;28;Budapest;Finance;Analyst;Female;Married;1100

Michael;35;Pécs;Sales;Representative;Male;Single;800

Sophia;29;Budapest;IT;Developer;Female;Married;1350

David;40;Szeged;Finance;Manager;Male;Married;1600

Sarah;27;Debrecen;IT;Designer;Female;Single;950

Daniel;32;Szeged;HR;Manager;Male;Single;1400

Emma;31;Pécs;Marketing;Coordinator;Female;Married;720

Matthew;34;Budapest;IT;Team Lead;Male;Single;1450

Olivia;26;Szeged;Sales;Representative;Female;Single;710

William;38;Budapest;Finance;Analyst;Male;Married;1150

Ava;23;Debrecen;IT;Developer;Female;Single;1300

James;29;Budapest;Marketing;Manager;Male;Single;950

Mia;33;Pécs;HR;Assistant;Female;Married;660

Benjamin;24;Szeged;Finance;Analyst;Male;Single;1120

Charlotte;36;Budapest;Sales;Representative;Female;Married;720

Logan;30;Debrecen;IT;Engineer;Male;Single;1150

Luna;28;Szeged;Finance;Manager;Female;Single;1400

Ethan;26;Pécs;IT;Designer;Male;Single;990

Harper;35;Budapest;Marketing;Coordinator;Female;Married;810

Liam;22;Budapest;IT;Developer;Male;Single;1250

Aria;31;Szeged;Finance;Analyst;Female;Married;930

Noah;37;Pécs;Sales;Representative;Male;Single;720

Grace;29;Budapest;IT;Team Lead;Female;Married;1520

Oliver;28;Debrecen;Marketing;Manager;Male;Single;1120

2023.10.13. Monitorok hagyományos megoldás

 Ne feledjük, hogy hétfőn TZ.

using System;

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

namespace monitorAlapOOP
{
    class Monitor
    {
        public string Gyarto { get; private set; } // ezt a propertyt nem dolgoztuk ki, továbbfejlesztésre vár
        public string Tipus { get; set; } //ha nincs private a set-nél, nem olyan erős a védelem
        public double Meret { get; set; }
        public double Ar { get; set; }
        public bool Gamer { get; set; }
        private double bruttoAr; //ennél az adattagnál kidolgozzuk a propertyt, így ő rejtett láthatóságú      
        public int Darab; //ez egy "sima" adattag, nem property (nem ajánlott ilyet írni)
        const double Afa = 27;

        public double BruttoAr  //ez egy property, ami a bruttoAr adattag "értékére vigyáz"
        {
            get { return bruttoAr; }
            set
            {
                if (value > Ar)
                {
                    bruttoAr = value;
                }
                else
                {
                    throw new Exception("HIBA! A bruttó érték nem nagyobb a nettónál! Az érték nulla marad.");
                }
            }
        }  

        public Monitor(string sor) //ez a konstruktor
        {
            List<string> kezelo = sor.Split(';').ToList();
            this.Gyarto = kezelo[0];
            this.Tipus = kezelo[1];
            this.Meret = Convert.ToDouble(kezelo[2].Replace('.', ','));
            this.Ar = Convert.ToDouble(kezelo[3]);
            if (kezelo.Contains("gamer")) //vagy: kezelo.Count == 5
            {
                this.Gamer = true;
            }
            else
            {
                this.Gamer = false;
            }
            this.Darab = 15;
            //KIVÉTELKEZELÉS (Hibakezelés):
            try //"próbáld meg ezt a részt végrehajtani":
            {
                this.BruttoAr = Convert.ToDouble(kezelo[3]) * (Afa / 100 + 1);

                //ha a hibakezelést akarjuk tesztelni, akkor vegyük ki ezt az egy sort megjegyzésből:
                //brutto = 1; //miután ez hibás értékadás, nem fog végrehajtódni, az érték nulla marad
                //és megjelenik a hibaüzenet
                //figyeljük meg 12. feladatot, ez a hiba ott is jelentkezik ugyanígy
            }
            catch (Exception ex) //"ha volt feldobva hiba futás közben, kapd el, kezeld helyesen és írd ki a feldobott üzenetet"
            {
                Console.WriteLine(ex.Message);
            }
            //itt nem közvetlenül az adattagba írunk, hiszen a <BruttoAr> propertyt használjuk itt,
            //ami a rejtett bruttoAr adattagba ír
            //ha itt rosszul számoljuk a bruttó árat, nem engedi beletenni az adattagba
            //(nyilván itt ugyanaz az ember írja mindkettőt, de megeshet, hogy ez nem így van)
        }


        public string GamerErteke(bool gmr)  //ez egy paraméteres függvény
        {
            if (gmr) return "játék monitor";
            else return "nem játék monitor";
        }

        public override string ToString() //virtuális metódus felülírása
        {
            //így is jó:
            //return "Gyártó: " + Gyarto + "; | Típus: " + Tipus + "; | Méret: " + Meret + " col;" + " | Nettó ár: " + Ar +" Ft\n";
            return $"Gyártó: {Gyarto}; | Típus: {Tipus} | Méret: {Meret} col; | Nettó ár: {Ar} Ft\n";
        }

        public double Ezer(double a)
        {
            return a / 1000;
        }

        public string Kiir() //ez a virtuális metódus helyett van, de meg kell tanulni inkább a virtuális metódust
        {
            return $"Gyártó: {Gyarto.ToUpper()};\nTípus: {Tipus.ToUpper()} ;\nMéret: {Meret} col;\nNettó ár (ezer ft): {Ezer(Ar):0}\nBruttó ár (ezer ft): {Ezer(BruttoAr):0}\nRaktárkészlet: {Darab} darab\n{GamerErteke(Gamer)}";
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
    //Monitor vásár
    //Egy hardver cég többféle monitort árul. A monitorokról a következő adatokat tároljuk: a monitor gyártója; típusa; mérete; ára;
    //illetve amelyik kifejezetten játékra való, ott még megadják azt is, hogy gamer.
    //A méret colban van, az ár nettó és forintban értjük.
    //Forrásfájl tartalma (a tartalmat használd így, ahogy van, az első sort majd nem kell figyelembe venni beolvasáskor):

    //Keszleten levo monitorok
    //Samsung;S24D330H;24;33000  
    //Acer;V227Qbi;21.5;31000  
    //AOC;24G2U;23.8;66000  
    //Samsung;Odyssey G9 C49g95TSSU;49;449989;gamer
    //LG;25UM58-P;25;56000  
    //Samsung;C27JG50QQU;27.5;91000  

    //Feladatok:
    //Lehetőleg minden kiírást a főprogram végezzen el. Próbálj minél több kódot újrahasznosítani.
    //1. Hozz létre egy osztályt a monitorok adatai számára. Olvasd be a fájl tartalmát.
    //2. Írd ki a monitorok összes adatát, soronként egy monitort a képernyőre. A kiírás így nézzen ki:
    //Gyártó: Samsung; Típus: S24D330H; Méret: 24 col; Nettó ár: 33000 Ft
    //2. Tárold az osztálypéldányokban a bruttó árat is (ÁFA: 27%, konkrétan a 27-tel számolj, ne 0,27-tel vagy más megoldással.)
    //3. Tételezzük fel, hogy mindegyik monitorból 15 db van készleten, ez a nyitókészlet. Mekkora a nyitó raktárkészlet bruttó (tehát áfával növelt) értéke?
    //Írj egy metódust, ami meghívásakor kiszámolja a raktárkészlet aktuális bruttó értékét. A főprogram írja ki az értéket.
    //4. Írd ki egy új fájlba, és a képernyőre az 50.000 Ft feletti nettó értékű monitorok összes adatát (a darabszámmal együtt) úgy,
    //hogy a szöveges adatok nagybetűsek legyenek, illetve az árak ezer forintba legyenek átszámítva.
    //Az ezer forintba átszámítást egy külön függvényben valósítsd meg.
    //5. Egy vevő keresi a HP EliteDisplay E242 monitort. Írd ki neki a képernyőre, hogy hány darab ilyen van a készleten.
    //Ha nincs a készleten, ajánlj neki egy olyan monitort, aminek az ára az átlaghoz fölülről közelít. Ehhez használd az átlagszámító függvényt (később lesz feladat).
    //6. Egy újabb vevőt csak az ár érdekli. Írd ki neki a legolcsóbb monitor méretét, és árát.
    //7. A cég akciót hirdet. A 70.000 Ft fölötti árú Samsung monitorok bruttó árából 5%-ot elenged.
    //Írd ki, hogy mennyit veszítene a cég az akcióval, ha az összes akciós monitort eladná.
    //8. Írd ki a képernyőre minden monitor esetén, hogy az adott monitor nettó ára a nettó átlag ár alatt van-e, vagy fölötte,
    //esetleg pontosan egyenlő az átlag árral. Ezt is a főprogram írja ki.
    //9. Modellezzük, hogy megrohamozták a vevők a boltot. 5 és 15 közötti random számú vásárló 1 vagy 2 random módon kiválasztott monitort vásárol,
    //ezzel csökkentve az eredeti készletet. Írd ki, hogy melyik monitorból mennyi maradt a boltban.
    //Vigyázz, hogy nulla darab alá ne mehessen a készlet. Ha az adott monitor éppen elfogyott, ajánlj neki egy másikat (lásd fent).
    //10. Írd ki a képernyőre, hogy a vásárlások után van-e olyan monitor, amelyikből mindegyik elfogyott.
    //11. Írd ki a gyártókat abc sorrendben a képernyőre. Oldd meg úgy is, hogy a metódus írja ki, és úgy is, hogy a főprogram.
    //12. Csökkentsd a legdrágább monitor bruttó árát 10%-kal, írd ki ezt az értéket a képernyőre.

    //A feladatsor egy lehetséges megoldása:

namespace monitorAlapOOP
{
    class Program
    {
        static void Main(string[] args)
        {
            //1. Hozz létre egy osztályt a monitorok adatai számára. Olvasd be a fájl tartalmát. Oldd meg, hogy bármennyi monitort is tudj kezelni.
            //Tárold az osztálypéldányokban a bruttó árat is (ÁFA: 27 %, konkrétan a 27 - tel számolj.)

            //ez a lista fogja tárolni az osztálypéldányokat, tehát az összes adatot,
            //ami a fájlból származik
            //Ez a hagyományos inicializálás:
            //List<Monitor> monitorok = new List<Monitor>();

            //Ez a fajta inicializálás C# 9.0-tól kezdve használható ilyen esetben:
            List<Monitor> monitorok = new();

            //ezzel is lehet strukturálni a kódot (region):
            #region 1. Feladat: Beolvasás
            Console.WriteLine("\n1. Feladat");
            foreach (var i in File.ReadAllLines(@"..\..\..\src\monitorok.txt").Skip(1))
            {
                monitorok.Add(new Monitor(i));
            }
            Console.WriteLine("Beolvasás kész.");
            #endregion

            //2. Írd ki az adatokat a képernyőre.
            Console.WriteLine("\n2. Feladat");
            foreach (var i in monitorok)
            {
                Console.WriteLine(i);
            }

            //3. Tételezzük fel, hogy mindegyik monitorból 15 db van készleten, ez a nyitókészlet. Mekkora a nyitó raktárkészlet bruttó (tehát áfával növelt) értéke?
            //Írj egy metódust, ami meghívásakor kiszámolja a raktárkészlet aktuális bruttó értékét. A főprogram írja ki az értéket.
            Console.WriteLine("\n3. Feladat");
            Console.WriteLine($"A raktárkészlet összértéke {Raktar(monitorok):0} Ft");

            //4. Írd ki egy új fájlba, és a képernyőre az 50000 Ft feletti nettó értékű monitorok összes adatát (a darabszámmal együtt) úgy,
            //hogy a szöveges adatok nagybetűsek legyenek, illetve az árak ezer forintba legyenek átszámítva.
            //Az ezer forintba átszámítást egy külön függvényben valósítsd meg.

            Console.WriteLine("\n4. Feladat");
            Console.WriteLine("Mentés...");
            FajlbaIras(monitorok);
            Console.WriteLine("Mentve\n");

            Console.WriteLine("\n4. Feladat másképp");
            Console.WriteLine("Mentés másképp...");
            FajlbaIras2(monitorok);
            Console.WriteLine("Mentve\n");

            //5. Egy vevő keresi a HP EliteDisplay E242 monitort. Írd ki neki a képernyőre, hogy hány darab ilyen van a készleten.
            //Ha nincs a készleten, ajánlj neki egy olyan monitort, aminek az ára az átlaghoz fölülről közelít. Ehhez használd az átlagszámító függvényt (később lesz feladat).
            Console.WriteLine("\n5. Feladat");
            Console.WriteLine("\nAjánlás");
            MonitorKereso(monitorok);

            //6. Egy újabb vevőt csak az ár érdekli. Írd ki neki a legolcsóbb monitor méretét, és árát.
            Console.WriteLine("\n6. Feladat");
            int index = Legolcsobb(monitorok);
            Console.WriteLine($"Legolcsóbb monitor {monitorok[index].Ar} Ft; {monitorok[index].Meret} col");

            //7. A cég akciót hirdet. A 70000 Ft fölötti árú Samsung monitorok bruttó árából 5%-ot elenged.
            //Írd ki, hogy mennyit veszítene a cég az akcióval, ha az összes akciós monitort eladná.                        
            Console.WriteLine("\n7. Feladat");
            Console.WriteLine($"A cég {SamsungAkcio(monitorok):0} Ft-ot veszítene.");

            //8. Írd ki a képernyőre minden monitor esetén, hogy az adott monitor nettó ára a nettó átlag ár alatt van-e, vagy fölötte,
            //esetleg pontosan egyenlő az átlag árral. Ezt is a főprogram írja ki.
            Console.WriteLine("\n8. Feladat");
            AtlagAlattiFolotti(monitorok);

            //9. Modellezzük, hogy megrohamozták a vevők a boltot. 5 és 15 közötti random számú vásárló
            //1 vagy 2 random módon kiválasztott monitort vásárol,
            //ezzel csökkentve az eredeti készletet. Írd ki, hogy melyik monitorból mennyi maradt a boltban.
            //Vigyázz, hogy nulla darab alá ne mehessen a készlet. Ha az adott monitor éppen elfogyott,
            //ajánlj neki egy másikat (lásd fent).
            Console.WriteLine("\n9. Feladat");
            Vasarlas(monitorok);

            //10. Írd ki a képernyőre, hogy a vásárlások után van-e olyan monitor, amelyikből mindegyik elfogyott.
            Console.WriteLine("\n10. Feladat");
            Elfogyott(monitorok);

            //11. Írd ki a gyártókat abc sorrendben a képernyőre. Oldd meg úgy is, hogy a metódus írja ki, és úgy is, hogy a főprogram.
            Console.WriteLine("\n11. Feladat/1");
            Console.WriteLine("A gyártók abc sorrendben, mindegyikből egy:");
            Console.WriteLine(AbcSorrend1(monitorok));

            Console.WriteLine("\n11. Feladat/2");
            AbcSorrend2(monitorok);

            //12. Csökkentsd a legdrágább monitor bruttó árát 10%-kal, írd ki ezt az értéket a képernyőre.
            Console.WriteLine("\n12. Feladat");
            Legdragabb(monitorok);

            Console.ReadLine();
        }
        static double NettoAtlag(List<Monitor> adatok)
        {
            //1. megoldás, ez is jó:
            //double atlag = 0;
            //for (int i = 0; i < adatok.Count; i++)
            //{
            //    atlag += adatok[i].Ar;
            //}
            //return atlag / adatok.Count;

            //2. megoldás
            List<double> arLista = new List<double>();
            for (int i = 0; i < adatok.Count; i++)
            {
                arLista.Add(adatok[i].Ar);
            }
            return arLista.Average();
        }

        static int Ajanlo(List<Monitor> adatok)
        {
            List<double> arakTavolsag = new List<double>();
            double atlag = NettoAtlag(adatok);
            for (int i = 0; i < adatok.Count; i++)
            {
                arakTavolsag.Add(adatok[i].Ar - atlag);
            }

            double min = double.MaxValue;
            int monitorIndex = 0;
            for (int i = 0; i < arakTavolsag.Count; i++)
            {
                if (arakTavolsag[i] > 0)
                {
                    if (arakTavolsag[i] < min)
                    {
                        min = arakTavolsag[i];
                        monitorIndex = i;
                    }
                }
            }
            return monitorIndex;
        }

        static string AbcSorrend1(List<Monitor> adatok)
        {
            List<string> gyartok = new List<string>();

            foreach (var item in adatok)
            {
                if (!gyartok.Contains(item.Gyarto))
                {
                    gyartok.Add(item.Gyarto);
                }
            }
            gyartok.Sort();
            return string.Join("\n", gyartok);
        }

        static void AbcSorrend2(List<Monitor> adatok)
        {
            List<string> gyartok = new List<string>();
            for (int i = 0; i < adatok.Count; i++)
            {
                if (!gyartok.Contains(adatok[i].Gyarto))
                {
                    gyartok.Add(adatok[i].Gyarto);
                }
            }
            gyartok.Sort();
            foreach (var item in gyartok)
            {
                Console.WriteLine(item);
            }
        }

        static double Raktar(List<Monitor> adatok)
        {
            double osszeg = 0;
            for (int i = 0; i < adatok.Count; i++)
            {
                osszeg += adatok[i].BruttoAr * adatok[i].Darab;
            }
            return osszeg;
        }

        static void AtlagAlattiFolotti(List<Monitor> adatok)
        {
            double atlagErteke = NettoAtlag(adatok);
            for (int i = 0; i < adatok.Count; i++)
            {
                Console.Write($"{adatok[i].Tipus} monitor ára az ");
                if (adatok[i].Ar < atlagErteke)
                {
                    Console.WriteLine("átlag alatt van.");
                }
                else
                    if (adatok[i].Ar > atlagErteke)
                {
                    Console.WriteLine("átlag fölött van.");
                }
                else
                {
                    Console.WriteLine("átlaggal egyenlő.");
                }
            }
        }

        static int Legolcsobb(List<Monitor> adatok)
        {
            List<double> arak = new List<double>();
            foreach (var item in adatok)
            {
                arak.Add(item.Ar);
            }
            return arak.IndexOf(arak.Min());
        }

        static void Legdragabb(List<Monitor> adatok)
        {
            List<double> arLista = new List<double>();
            for (int i = 0; i < adatok.Count; i++)
            {
                arLista.Add(adatok[i].BruttoAr);
            }
            double legdragabb = arLista.Max();
            double brutto = 0;
            foreach (var item in adatok)
            {
                brutto = item.BruttoAr;
                if (brutto == legdragabb)
                {
                    Console.WriteLine($"{item.Gyarto} {item.Tipus} gép csökkentett bruttó ára {brutto - brutto * 0.1:0} Ft");
                    //itt nem változott meg az eredeti érték, és mindegyik monitorra vonatkozóan kiírjuk
                }
            }
        }

        static void Elfogyott(List<Monitor> adatok)
        {
            bool log = false;
            for (int i = 0; i < adatok.Count; i++)
            {
                if (adatok[i].Darab == 0)
                {
                    Console.WriteLine($"{adatok[i].Gyarto} {adatok[i].Tipus} monitor teljesen elfogyott.");
                    log = true;
                }
            }
            if (!log)
            {
                Console.WriteLine("Minden monitorból van még készleten minimum 1 db.");
            }
        }

        static void Vasarlas(List<Monitor> adatok)
        {
            Random rnd = new Random();
            int randomInt;
            int randomSzam1 = rnd.Next(5, 16); //Teszteld 100 vásárlóval, akkor biztos lesz, amelyik elfogy.
            int randomSzam2 = rnd.Next(1, 3);
            for (int i = 0; i < randomSzam1; i++)
            {
                for (int j = 0; j < randomSzam2; j++)
                {
                    randomInt = rnd.Next(0, adatok.Count);

                    if (adatok[randomInt].Darab > 0)
                    {
                        adatok[randomInt].Darab--;
                        Console.WriteLine($"{adatok[randomInt].Gyarto} {adatok[randomInt].Tipus} monitorból {adatok[randomInt].Darab} db maradt készleten.");
                    }
                    else
                    {
                        int index = Ajanlo(adatok);
                        Console.WriteLine($"A keresett monitor elfogyott. Ajánlott monitor: {adatok[index].Gyarto} {adatok[index].Tipus}");
                    }
                }
            }
        }

        static double SamsungAkcio(List<Monitor> monitorok)
        {
            List<double> hetvenPluszArak = new List<double>();
            for (int i = 0; i < monitorok.Count; i++)
            {
                if (monitorok[i].Ar >= 70000 && monitorok[i].Gyarto == "Samsung")
                {
                    hetvenPluszArak.Add((monitorok[i].BruttoAr - (monitorok[i].BruttoAr * 0.05)) * monitorok[i].Darab);
                }
            }
            return hetvenPluszArak.Sum();
        }

        static void MonitorKereso(List<Monitor> monitorok)
        {
            List<double> arak = new List<double>();
            List<string> adatok = new List<string>();
            double atlagErtek = NettoAtlag(monitorok);
            string kerMonitor = "HP EliteDisplay E242";

            for (int i = 0; i < monitorok.Count; i++)
            {
                adatok.Add(monitorok[i].Gyarto + " " + monitorok[i].Tipus);
            }
            if (adatok.Contains(kerMonitor))
            {
                Console.WriteLine($"{kerMonitor} monitorból {monitorok[adatok.IndexOf(kerMonitor)].Darab} darab van készleten.");
            }
            else
            {
                int index = Ajanlo(monitorok);
                Console.WriteLine($"{monitorok[index].Gyarto} {monitorok[index].Tipus} monitort ajánlom, ennek ára: {monitorok[index].Ar} Ft");
            }
        }

        static void FajlbaIras(List<Monitor> monitorok)
        {
            //ez nem eléggé tiszta kód:
            //StreamWriter sw = new StreamWriter("out.txt");
            //string ki = String.Empty;
            //for (int i = 0; i < monitorok.Count; i++)
            //{
            //    if (monitorok[i].ar > 50000)
            //    {
            //        ki = monitorok[i].kiir();
            //        Console.WriteLine(ki);
            //        sw.WriteLine(ki);
            //        Console.WriteLine();
            //    }
            //}
            //sw.Close();

            using (StreamWriter sw = new StreamWriter("out.txt"))
            {
                string ki = String.Empty;
                for (int i = 0; i < monitorok.Count; i++)
                {
                    if (monitorok[i].Ar > 50000)
                    {
                        ki = monitorok[i].Kiir();
                        Console.WriteLine(ki);
                        sw.WriteLine(ki);
                        Console.WriteLine();
                    }
                }
            }
        }

        static void FajlbaIras2(List<Monitor> m)
        {
            List<string> toFile = new List<string>();
            string kiIr = String.Empty;
            for (int i = 0; i < m.Count; i++)
            {
                if (m[i].Ar > 50000)
                {
                    kiIr = m[i].Kiir();
                    toFile.Add(kiIr);
                    Console.WriteLine(kiIr);
                    Console.WriteLine();
                }
            }
            File.WriteAllLines("out1.txt", toFile);
        }
    }
}



2024.04.25. Időjárás app

 Feladat: Időjárás app - OOP módszerekkel, haladóknak adatkötéssel Az alkalmazás célja, hogy a felhasználók hozzáadjanak és eltávolítsanak v...