Menetrend-2020 május (idegen)

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


namespace ConsoleApp3
{
    class Program
    {
        struct vonat
        {
            public int vonat_ID;  //vonat az
            public int allomas_ID;
            public int ora;
            public int perc;
            public bool inerk; //Indul=true Erk=false

        }
        struct vonathol
        {
            public int allomasID_hol; //állomásazonosito
            public int indul_hol; //indulási idő
            public int erkez_hol; //

        }

        static void Main(string[] args)
        {

            vonat[] adat = new vonat[1000]; //ebben rögzitjük az összes adatot
            int szamol = 0;//adatsorok száma

            string[] adatsor = new string[6]; //szétvágáshoz
            StreamReader sr = new StreamReader("vonat.txt");

            while (!sr.EndOfStream)
            {

                adatsor = sr.ReadLine().Split('\t');
                adat[szamol].vonat_ID = int.Parse(adatsor[0]);
                adat[szamol].allomas_ID = int.Parse(adatsor[1]);
                adat[szamol].ora = int.Parse(adatsor[2]);
                adat[szamol].perc = int.Parse(adatsor[3]);
                adat[szamol].inerk = false;
                if (adatsor[4] == "I")
                {
                    adat[szamol].inerk = true;
                }
                szamol++;
            }
            sr.Close();

            //2.Feladat
            Console.WriteLine("2.Feladat: ");
            int vonatmax = int.MinValue;
            int allomasmax = int.MinValue;

            for (int i = 0; i <= szamol; i++)
            {
                if (adat[i].vonat_ID > vonatmax)
                {
                    vonatmax = adat[i].vonat_ID;
                }

                if (adat[i].allomas_ID > allomasmax)
                {
                    allomasmax = adat[i].allomas_ID;
                }
            }
            Console.WriteLine("Az állomások száma: {0}\nA vonatok száma: {1}", allomasmax, vonatmax);

            //3.feladat
            Console.WriteLine("\n3.Feladat:");
            int[] varmax = new int[vonatmax + 1]; //vontonkénti max várakozási idő
            int[] allmax = new int[vonatmax + 1]; //itt várt a legtöbbet
            int[] maxvonat = new int[vonatmax + 1]; // ez a vonat volt az
            int erkezes = 0, indulas = 0, varakoz = 0;
            for (int i = 0; i <= vonatmax; i++)
            {
                varmax[i] = 0;
                for (int j = 0; j < szamol; j++)
                {

                    if ((adat[j].inerk == false) || (adat[j].allomas_ID == 0)) //le kell kezelni, mert a 0. állomásra nem érkezik vonat
                    {
                        erkezes = adat[j].ora * 60 + adat[j].perc;

                    }
                    else
                    {
                        indulas = adat[j].ora * 60 + adat[j].perc;
                        varakoz = indulas - erkezes;
                        if (varakoz > varmax[i])
                        {
                            varmax[i] = varakoz;
                            allmax[i] = adat[j].allomas_ID;
                            maxvonat[i] = adat[j].vonat_ID;
                        }

                    }
                }
            }
            int megoldas = varmax.Max(); //legnagyobb várakozási idő
            int i3 = 1;
            bool megvan = false;

            while (megvan == false)
            {

                if (megoldas == varmax[i3])
                {
                    Console.WriteLine("A(z) {0}. vonat a(z) {1}. állomáson {2} percet állt", maxvonat[i3], allmax[i3], megoldas);
                    megvan = true;
                }

            }
            //4.feladat
            Console.WriteLine("\n4. Feladat:");
            Console.Write("Adja meg a vonat azonosítóját!");
            string s4 = Console.ReadLine();
            vonat bekertvonat;
            bekertvonat.vonat_ID = int.Parse(s4);
            Console.Write("Adjon meg egy időpontot (óra perc!");
            s4 = Console.ReadLine();
            string[] bonto = new string[2];
            bonto = s4.Split(' ');
            bekertvonat.ora = int.Parse(bonto[0]);
            bekertvonat.perc = int.Parse(bonto[1]);


            ////5. feladat

            Console.WriteLine("\n5.feladat: ");

            int indult = 0; //ekkor indult
            int erkezett = 0; //ekkor érketztett

            int i5 = 1;
            do
            {
                if (bekertvonat.vonat_ID == adat[i5].vonat_ID)
                {
                    indult = adat[i5].ora * 60 + adat[i5].perc;
                }
                i5++;

            } while (indult == 0);
            do
            {  //keresett vonat az állomásra érkezett
                if ((bekertvonat.vonat_ID == adat[i5].vonat_ID) && (adat[i5].allomas_ID == allomasmax))
                {
                    erkezett = adat[i5].ora * 60 + adat[i5].perc;

                }
                i5++;
            } while (i5 < szamol);

            //teljes út hossza

            int uthossza = erkezett - indult;


            if (uthossza > 142)
            {
                Console.WriteLine("A(z) {0}. vonat útja {1} perccel hosszabb volt azt előírtnál.", bekertvonat.vonat_ID, uthossza - 142);

            }
            if (uthossza < 142)
            {
                Console.WriteLine("A(z) {0}. vonat útja {1} perccel rövidebb volt azt előírtnál.", bekertvonat.vonat_ID, 142 - uthossza);
            }
            if (uthossza == 142)
            {
                Console.WriteLine("A(z) {0}. vonat útja pontosan megegyezik az előírttal.", bekertvonat.vonat_ID);
            }


            //6. feladat

            Console.WriteLine("\n6.Feladat:");
            string filenev = "halad";
            filenev += bekertvonat.vonat_ID;
            filenev += ".txt";
            StreamWriter sw = new StreamWriter(filenev);
            for (int i = 1; i <= szamol; i++)
            {
                if ((adat[i].vonat_ID == bekertvonat.vonat_ID) && (adat[i].inerk == false))
                {
                    sw.Write("{0}. állomás: {1}:{2}\n", adat[i].allomas_ID, adat[i].ora, adat[i].perc);


                }

            }
            sw.Close();
            Console.WriteLine("{0} elkészült", filenev);

            //7. feladat
            Console.WriteLine("7. feladat: ");
            //struct fent

            int vizsgalt7 = bekertvonat.ora * 60 + bekertvonat.perc;          //Ez a vizsgált időpont
            vonathol[] sz = new vonathol[vonatmax + 1];
            for (int j = 1; j <= vonatmax; j++)
            {
                for (int i = 1; i <= szamol; i++)
                {
                    if ((adat[i].inerk == true) && (adat[i].vonat_ID == j))           //A megfelelő vonat indul
                    {
                        sz[adat[i].allomas_ID].allomasID_hol = adat[i].allomas_ID;
                        sz[adat[i].allomas_ID].indul_hol = adat[i].ora * 60 + adat[i].perc;
                    }
                    if ((adat[i].inerk == false) && (adat[i].vonat_ID == j))            //A megfelelő vonat érkezik
                    {
                        sz[adat[i].allomas_ID].allomasID_hol = adat[i].allomas_ID;
                        sz[adat[i].allomas_ID].erkez_hol = adat[i].ora * 60 + adat[i].perc;
                    }
                }
                //for (int i = 1; i <allmax; i++)
                //{ Console.WriteLine("{0}. állomás. Indul: {1} Érkezik: {2} - VONAT: {3}",i,sz[i].indul,sz[i].erkez,j); }
                //Csak tesztre!
                for (int i = 1; i < allomasmax; i++)
                {
                    if ((vizsgalt7 <= sz[i].indul_hol) && (vizsgalt7 >= sz[i].erkez_hol))
                    {
                        Console.WriteLine("A(z) {0}. vonat a {1}. állomáson állt. ", j, i);
                    }
                    if ((vizsgalt7 > sz[i].indul_hol) && (vizsgalt7 < sz[i + 1].erkez_hol))
                    {
                        Console.WriteLine("A(z) {0}. vonat a {1}. és a {2}. állomás között járt.", j, i, i + 1);
                    }
                }
            }

        }
    }

}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
using System;
using System.Collections.Generic;
using System.IO;

namespace menetrend
{
    class All
    {
        public int VonatID { get; set; }
        public int AllomasID { get; set; }
        public int ErkOra { get; set; }
        public int ErkPerc { get; set; }
        public int IndOra { get; set; }
        public int IndPerc { get; set; }
        public int Var { get; set; }
        public All(int vID, int aID, int ora, int perc)
        {
            VonatID = vID;
            AllomasID = aID;
            ErkOra = ora;
            ErkPerc = perc;
            IndOra = IndPerc = -1;
            Var = 0;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            StreamReader sr = new StreamReader("vonat.txt");
            List<All> allas = new List<All>();
            int vonatDB = -1;
            int allomasDB = -1;
            while (!sr.EndOfStream)
            {
                string[] adatsor = sr.ReadLine().Split();
                int vonatID = int.Parse(adatsor[0]);
                int allomasID = int.Parse(adatsor[1]);
                int ora = int.Parse(adatsor[2]);
                int perc = int.Parse(adatsor[3]);
                if (adatsor[4] == "E")
                    //létrehozás
                    allas.Add(new All(vonatID, allomasID, ora, perc));
                else //indul
                {
                    if (allomasID == 0)
                    {
                        allas.Add(new All(vonatID, allomasID, -1, -1));
                    }
                    //kiválasztás (tudjuk, hogy megérkezett!)
                    int melyik = allas.Count-1; //így az első amit megnéz az éppen létrehozott
                    while (!(vonatID == allas[melyik].VonatID && allomasID == allas[melyik].AllomasID))
                    {
                        melyik--;
                    }
                    //módosítás
                    allas[melyik].IndOra = ora;
                    allas[melyik].IndPerc = perc;
                    allas[melyik].Var = (allas[melyik].ErkOra == -1) ? 0
                                        :(allas[melyik].IndOra * 60 + allas[melyik].IndPerc - (allas[melyik].ErkOra * 60 + allas[melyik].ErkPerc));
                }
                if (vonatID>vonatDB)
                {
                    vonatDB = vonatID;
                }
                if (allomasID>allomasDB)
                {
                    allomasDB = allomasID;
                }
            }
            sr.Close();

            Console.WriteLine("2. feladat");
            Console.WriteLine("Az állomások száma: {0}", allomasDB+1);
            Console.WriteLine("A vonatok száma: {0}", vonatDB);

            Console.WriteLine("3. feladat");
            //max. kiválasztás
            int maxh = 0;
            for (int i = 1; i < allas.Count; i++)
            {
                if (allas[maxh].Var < allas[i].Var)
                {
                    maxh = i;
                }
            }
            Console.WriteLine("A(z) {0}. vonat a(z) {1}. állomáson {2} percet állt.", allas[maxh].VonatID, allas[maxh].AllomasID, allas[maxh].Var);


            Console.WriteLine("4. feladat");
            Console.Write("Adja meg egy vonat azonosítóját! ");
            int vAzon = int.Parse(Console.ReadLine());
            Console.Write("Adjon meg egy időpontot(óra perc)! ");
            string[] most = Console.ReadLine().Split(' ');
            int idoMost = int.Parse(most[0]) * 60 + int.Parse(most[1]);

            #region 5-7. feladat előfeldolgozás

            //5. feladathoz első indulás és utolsó érkezés kigyűjtése
            int eloirtido = 2 * 60 + 22;

            //6. feladathoz adott vonat menetrendjének kigyűjtése fájlba
            StreamWriter sw = new StreamWriter("halad" + vAzon.ToString() + ".txt");

            //7. feladathoz minden vonat menetrendjének elkészítése
            List<All>[] menetrend = new List<All>[vonatDB + 1];
            for (int i = 1; i <= vonatDB; i++)
            {
                menetrend[i] = new List<All>();
            }

            int menetido = 0;
            for (int i = 0; i < allas.Count; i++)
            {
                menetrend[allas[i].VonatID].Add(allas[i]); //7. feladathoz minden megállásra

                if (allas[i].VonatID == vAzon) //ez a vonat
                {
                    if (allas[i].ErkOra != -1) //nem induló állomás
                    {
                        sw.WriteLine("{0}. állomás: {1}:{2}", allas[i].AllomasID, allas[i].ErkOra, allas[i].ErkPerc); //6. feladat

                        if (allas[i].IndOra == -1) //végállomás, nem megy tovább
                        {
                            menetido += (allas[i].ErkOra * 60 + allas[i].ErkPerc); //5. feladathoz
                        }
                    }
                    else //induló állomás
                    {
                        menetido -= (allas[i].IndOra * 60 + allas[i].IndPerc); //5. feladathoz
                    }
                }
            }
            sw.Close();
            #endregion

            Console.WriteLine("5. feladat");
            Console.Write("A(z) {0}. vonat útja ", vAzon);
            if (menetido < eloirtido)
            {
                Console.WriteLine("{0} perccel rövidebb volt az előírtnál.", eloirtido-menetido);
            }
            else if (menetido > eloirtido)
            {
                Console.WriteLine("{0} perccel hosszabb volt az előírtnál.", menetido-eloirtido);
            }
            else
            {
                Console.WriteLine("pontosan az előírt ideig tartott.");
            }

            Console.WriteLine("7. feladat");

            for (int v = 1; v <=vonatDB; v++)
            {
                int start = menetrend[v][0].IndOra * 60 + menetrend[v][0].IndPerc;
                int cel = menetrend[v][menetrend[v].Count - 1].ErkOra * 60 + menetrend[v][menetrend[v].Count - 1].ErkPerc;
                if ( start < idoMost && idoMost < cel)
                {
                    //első időn túli indulás keresése
                    int jovo = 0;
                    while (menetrend[v][jovo].IndOra != -1 && menetrend[v][jovo].IndOra * 60 + menetrend[v][jovo].IndPerc < idoMost)
                    {
                        jovo++;
                    }
                    //indulási idő >= idoMost vagy végállomás
                    if (menetrend[v][jovo].ErkOra * 60 + menetrend[v][jovo].ErkPerc <= idoMost) //állomásra érkezés <= időMost
                    {
                        Console.WriteLine("A(z) {0}. vonat a {1}. állomáson állt.", v, menetrend[v][jovo].AllomasID );
                    }
                    else //állomásra érkezés > időMost, de az előző állomásról elindult (előzőind < idoMost, mert a ciklus ott nem állt le)
                    {
                        Console.WriteLine("A(z) {0}. vonat a {1}. és a {2}. állomás között járt.", v, menetrend[v][jovo - 1].AllomasID, menetrend[v][jovo].AllomasID);
                    }
                }
            }
            Console.ReadLine();
        }
    }
}