コード例 #1
0
ファイル: VersenyzoKezelo.cs プロジェクト: dretax/TourdeNIK
        /// <summary>
        /// Csak is a delegate miatt lett létrehozva a feladat szerint.
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        internal Versenyzo AlertRemoval(string id)
        {
            VersenyzoKezelo.ListElement currentElement = _FirstElement; // Vesszük az első elemet

            // Addig megyünk amíg a jelenlegi elemünk nem null, és az érték nem egyezik a megadottal.
            while (currentElement != null)
            {
                VersenyBrigad             brigad  = currentElement.ElementValue;
                VersenyBrigad.ListElement element = brigad.FirstElement;
                while (element != null)
                {
                    Versenyzo v2 = element.ElementValue;
                    if (v2.VersenyzoAzonosito == id)
                    {
                        return(v2);
                    }
                    if (element.LastElement)
                    {
                        break;
                    }
                    element = element.NextElement;
                }

                currentElement = currentElement.NextElement; // Vesszük a következő elemet
            }
            return(null);
        }
コード例 #2
0
ファイル: Versenyzo.cs プロジェクト: dretax/TourdeNIK
 /// <summary>
 /// Ezt a delegált fogja meghívni amennyiben törlésre kerül a versenyző.
 /// </summary>
 /// <param name="v"></param>
 private void NemVersenyzikTobbet(Versenyzo v)
 {
     if (v == this)
     {
         Console.WriteLine(v.Nev + " " + v.VersenyzoAzonosito + " nem versenyzik többet!");
     }
 }
コード例 #3
0
        /*public void Add(TourdeNIK.Versenyzo element)
         * {
         *  // Létrehozunk egy új lista elementet
         *  ListElement uj = new ListElement(element);
         *  //Console.WriteLine("Hozzáadott érték: " + uj.ElementValue);
         *
         *  // Ha a mostani elem az első a listában, akkor ez lesz az "utolsó" elem is egyben.
         *  if (_FirstElement == null)
         *  {
         *      //Console.WriteLine("Első elem nulla, úgyhogy ez az utolsó is egyben: " + uj.ElementValue);
         *      //Console.WriteLine();
         *      uj.LastElement = true;
         *  }
         *  else
         *  {
         *      // Fussunk végig a láncolt listánkon, vegyük a mostani első elemünket.
         *      ListElement aktualis = _FirstElement;
         *      while (aktualis != null && !aktualis.LastElement)
         *      {
         *          //Console.WriteLine("Mostani: " + aktualis.ElementValue);
         *          aktualis = aktualis.NextElement; // Addig keresgélünk még nem az utolsó elemnél vagyunk.
         *          //Console.WriteLine("Következő: " + aktualis.ElementValue);
         *          //Console.WriteLine();
         *      }
         *
         *      if (aktualis != null)
         *      {
         *          //Console.WriteLine("Utolsó elem: " + aktualis.ElementValue);
         *          aktualis.NextElement = uj; // utolsó elemből elérhető a legelső,
         *          //Console.WriteLine("Elérhető első elem: " + aktualis.NextElement.ElementValue);
         *      }
         *  }
         *
         *  // Az újonnan létrehozott elemnek megadjuk az előtte lévő elemet, de ez null ha az első element tesszük a listába
         *  uj.NextElement = _FirstElement;
         *  //Console.WriteLine(uj.LastElement + " e");
         *
         *  // Az első elem az újonnan létrehozott lesz.
         *  _FirstElement = uj;
         *  _ListCount++;
         * }*/

        internal ListElement Find(Versenyzo element)
        {
            ListElement aktualis = _FirstElement;

            while (aktualis != null && !aktualis.ElementValue.Equals(element) && !aktualis.LastElement)
            {
                aktualis = aktualis.NextElement;
            }
            return(aktualis);
        }
コード例 #4
0
ファイル: VersenyzoKezelo.cs プロジェクト: dretax/TourdeNIK
 /// <summary>
 /// Törli a versenyzőt a specifikus brigádból.
 /// </summary>
 /// <param name="b"></param>
 /// <param name="v"></param>
 public void VersenyzoTorolFromBrigad(VersenyBrigad b, Versenyzo v)
 {
     b.Remove(v);
     // Ha véletlenül az első elem kerülne törlésre frissítsük az kulcs értéket a legkisebbre.
     // Így megtartjuk, hogy a brigádok mindíg a legkisebb azonosítószámmal vannak feltüntetve.
     if (b.FirstElement != null)
     {
         this._FirstElement.Key = b.FirstElement.Key;
     }
 }
コード例 #5
0
        /// <summary>
        /// Beilleszt egy versenyzőt a Brigádba rendezetten. (EA jegyzet alapján.)
        /// </summary>
        /// <param name="element"></param>
        public void AddInSortedWay(Versenyzo element)
        {
            ListElement uj = new ListElement(element);

            ListElement p = _FirstElement;

            // Ha a mostani elem az első a listában, akkor ez lesz az "utolsó" elem is egyben.
            if (p == null)
            {
                uj.LastElement = true;
            }

            ListElement e = null;

            while (p != null && p.Key < uj.Key)
            {
                e = p;
                // Ha az jelenlegi elemünk kisebb mint a behelyezett elemünk, akkor már nem az lesz az utolsó elem.
                if (e.LastElement)
                {
                    e.LastElement  = false;
                    uj.LastElement = true;
                    break;
                }
                //Console.WriteLine("E értéke: " + e.Key);
                //Console.WriteLine("element értéke: " + element.VersenyzoAzonositoSzam);
                p = p.NextElement;

                /*if (p != null)
                 * {
                 *  Console.WriteLine("P értéke: " + p.Key);
                 * }*/
            }

            if (e == null)
            {
                uj.NextElement = _FirstElement;
                _FirstElement  = uj;
            }
            else
            {
                uj.NextElement = p;

                e.NextElement = uj;
            }

            if (uj.LastElement) // Ha az újonnan behelyezett érték az utolsó elem akkor adjuk meg neki az első elemet mint következő érték.
            {
                //Console.WriteLine("Last element értéke: " + uj.Key);
                uj.NextElement = _FirstElement;
                //Console.WriteLine("F: " + uj.NextElement.Key);
            }

            _ListCount++;
        }
コード例 #6
0
ファイル: VersenyzoKezelo.cs プロジェクト: dretax/TourdeNIK
        /// <summary>
        /// Ezt a methodot úgy írtam meg, hogy az összes brigádot végig nézi egy adott versenyzőért, és ha megtalálja törli.
        /// Nem feltétlenül szükséges a használata, csak előre megcsináltam ha esetleg kellene.
        /// </summary>
        /// <param name="v"></param>
        public bool VersenyzoTorol(string id)
        {
            VersenyzoKezelo.ListElement currentElement = _FirstElement; // Vesszük az első elemet

            // Addig megyünk amíg a jelenlegi elemünk nem null, és az érték nem egyezik a megadottal.
            while (currentElement != null)
            {
                VersenyBrigad             brigad  = currentElement.ElementValue;
                VersenyBrigad.ListElement element = brigad.FirstElement;
                while (element != null)
                {
                    Versenyzo v2 = element.ElementValue;
                    if (v2.VersenyzoAzonosito == id)
                    {
                        brigad.Remove(v2);
                        if (brigad.FirstElement == null)
                        {
                            VersenyBrigadDelete(brigad);
                        }
                        else
                        {
                            // Ha véletlenül az első elem kerülne törlésre frissítsük az kulcs értéket a legkisebbre.
                            // Így megtartjuk, hogy a brigádok mindíg a legkisebb azonosítószámmal vannak feltüntetve.
                            if (brigad.FirstElement != null)
                            {
                                this._FirstElement.Key = brigad.FirstElement.Key;
                            }
                        }

                        return(true);
                    }
                    if (element.LastElement)
                    {
                        break;
                    }
                    element = element.NextElement;
                }

                currentElement = currentElement.NextElement; // Vesszük a következő elemet
            }

            return(false);
        }
コード例 #7
0
        /// <summary>
        /// Törli az adott versenyzőt a brigádból. Ez végig nézi az összes brigádot (Egyébként feladat szerint fölöslegesen, mert 1 ember sose lesz 1 brigádban.)
        /// </summary>
        /// <param name="element"></param>
        public void Remove(Versenyzo element)
        {
            ListElement currentElement = _FirstElement; // Vesszük az első elemet
            ListElement lastElement    = null;

            // Addig megyünk amíg a jelenlegi elemünk nem null, és az érték nem egyezik a megadottal, illetve nem az utolsó elemnél tartunk.
            while (currentElement != null && !currentElement.ElementValue.Equals(element) && !currentElement.LastElement)
            {
                lastElement    = currentElement;             // Az "utolsó" elemünk lesz a jelenlegi elem. Ez akar lenni a keresett elem előtti elem.
                currentElement = currentElement.NextElement; // Vesszük a következő elemet
            }
            if (currentElement != null)
            {
                if (lastElement != null) // Ha van utolsó értékünk
                {
                    //Console.WriteLine("Megvan az elem: " + currentElement.ElementValue);
                    //Console.WriteLine("Az előtte lévő elem értéke: " + lastElement.ElementValue);
                    // Ha az utolsó elemet töröltük tegyük meg az előtte lévőt utolsónak.
                    if (currentElement.LastElement)
                    {
                        lastElement.LastElement = true;
                    }
                    lastElement.NextElement = currentElement.NextElement; // Ha az utolsó elemet töröltük akkor a következő az első lesz, ha nem akkor pedig a törölt elem utáni.
                    //Console.WriteLine("last element nem null, és az utáni értéke: " + lastElement.NextElement.ElementValue);
                }
                else
                {
                    _FirstElement = currentElement.NextElement; // Ez null lesz ha a listánk abszolút üres lesz.

                    /*if (_FirstElement == null)
                     * {
                     *  Console.WriteLine("Null, üres");
                     * }
                     * else
                     * {
                     *  Console.WriteLine("First element: " + _FirstElement.ElementValue + " kövi: " +
                     *                    currentElement.NextElement.ElementValue);
                     * }*/
                }
                _ListCount--;
            }
        }
コード例 #8
0
        /// <summary>
        /// Átalakítja a láncolt listánkat egy két dimenziós tömbbé, és tulajdonképpen annyi oszlopot hoz
        /// létre ahány verseny van, illetve annyi sort ahány versenyző van a brigádban.
        /// Ezt követően a Backtrack logikája alapján elkezdi őket besorolni a lehetséges megoldásokkal
        /// az optimális egyetlen lehetőséghez.
        /// </summary>
        /// <param name="versenyek"></param>
        /// <param name="M"></param>
        /// <returns></returns>
        private Versenyzo[,] ConvertListTo2DimArray(RegularChainedList <Verseny> versenyek, ref int[] M)
        {
            // tesztként ez 7 oszlop és 3 sor lesz
            Versenyzo[,] tomb = new Versenyzo[versenyek.Count, Count];
            //Console.WriteLine("Versenyek: " + versenyek.Count);
            //Console.WriteLine("BR: " + Count);
            for (int i = 0; i < M.Length; i++)
            {
                M[i] = -1;
            }

            var aktualis = FirstElement;

            while (aktualis != null)
            {
                //Console.WriteLine("nev: " + aktualis.ElementValue.Nev);
                var versenyekelement = aktualis.ElementValue.Versenyek.FirstElement;
                while (versenyekelement != null)
                {
                    //Console.WriteLine("Verseny ami jön: " + versenyekelement.ElementValue.Megnevezes);
                    int index = int.Parse(versenyekelement.ElementValue.Megnevezes.Split('y')[1]) - 1;
                    //Console.WriteLine("M index: " + M[index] + " utána: " + (M[index] + 1) + " igazi idx: " + index + " L: " + M.Length);
                    tomb[index, ++M[index]] = aktualis.ElementValue;
                    if (versenyekelement.LastElement)
                    {
                        break;
                    }
                    versenyekelement = versenyekelement.NextElement;
                }
                if (aktualis.LastElement)
                {
                    break;
                }
                aktualis = aktualis.NextElement;
            }
            return(tomb);
        }
コード例 #9
0
        /// <summary>
        /// Beosztja az embereket úgy, hogy azonos versenyeken vegyenek részt.
        /// A listájukat nem, ez a method vehető úgy, hogy a végleges verseny listát
        /// hozza létre a résztvevőknek, hogy kinek hol kell szerepelnie.
        /// </summary>
        /// <param name="versenyek"></param>
        /// <returns></returns>
        public string[] BrigadBeosztas(RegularChainedList <Verseny> versenyek)
        {
            int[] M = new int[versenyek.Count];
            Versenyzo[,] tomb = ConvertListTo2DimArray(versenyek, ref M);

            /*foreach (var x in tomb)
             * {
             *  if (x != null)
             *  {
             *      Console.WriteLine("BEKERÜLT: " + x.Nev);
             *  }
             *  else
             *  {
             *      //Console.WriteLine("null");
             *  }
             * }*/
            var beosztottCsapat = new Versenyzo[versenyek.Count];

            bool van = false;

            BTS(0, ref beosztottCsapat, ref van, M, tomb);

            if (van)
            {
                //Console.WriteLine("VAN MEGOLDÁS GEC");
                string[] nevek = new string[beosztottCsapat.Length];
                for (int i = 0; i < nevek.Length; i++)
                {
                    //Console.WriteLine(beosztottCsapat[i].Nev);
                    nevek[i] = beosztottCsapat[i].Nev;
                }

                return(nevek);
            }

            throw new BTSException("Nem sikerült optimális megoldást találni.");
        }
コード例 #10
0
ファイル: Program.cs プロジェクト: dretax/TourdeNIK
        public static void Main(string[] args)
        {
            Randomizer = new Random();

            if (!File.Exists("Brigadok.ini"))
            {
                throw new FileNotFoundException("Brigádok Ini file hiányzik!");
            }

            if (!File.Exists("Versenyek.ini"))
            {
                throw new FileNotFoundException("Versenyek Ini file hiányzik!");
            }

            // Kezelő Statikus Inicializálója
            VersenyzoKezelo.InitializeKezelo();
            VersenyzoKezelo handler = VersenyzoKezelo.Instance;

            // Versenyek beolvasása
            IniParser      versenyek                    = new IniParser("Versenyek.ini");
            List <Verseny> AvailableRacesNORML          = new List <Verseny>();
            RegularChainedList <Verseny> AvailableRaces = new RegularChainedList <Verseny>();

            try
            {
                foreach (var x in versenyek.EnumSection("Versenyek"))
                {
                    AvailableRaces.Add(new Verseny(x));

                    AvailableRacesNORML.Add(new Verseny(x));
                }
            }
            catch (Exception ex)
            {
                throw new FileLoadException("Hiba a versenyek file olvasásakor! " + ex);
            }


            // Versenyzők és brigádjaik/adataik beolvasása.
            IniParser ini = new IniParser("Brigadok.ini");

            try
            {
                //Versenyzo vteszt = null;
                //VersenyBrigad bteszt = null;
                foreach (var x in ini.Sections) // Végig megyünk az összes section-n [Section1]
                {
                    VersenyBrigad
                             brigad = new VersenyBrigad(x); // Létrehozzuk a brigádot, de még nem adjuk hozzá a listához.
                    foreach (var y in ini.EnumSection(x))
                    {
                        var data = ini.GetSetting(x, y).Split('~');
                        if (data[1].ToLower() != "f" && data[1].ToLower() != "n")
                        {
                            throw new InvalidRacerDatas("Hibás versenyző nem!");
                        }

                        Versenyzo
                            v = new Versenyzo(y, data[1],
                                              data[0]); // Létrehozzuk a versenyzőt az adatokkal, majd hozzáadjuk a brigádhoz rendezett beilesztéssel
                        handler.VersenyzoHozzaAdd(brigad, v);
                        foreach (var z in data[2].Split(','))
                        {
                            foreach (var verseny in AvailableRacesNORML)
                            {
                                if (verseny.Megnevezes == z)
                                {
                                    v.Versenyek.Add(verseny);
                                }
                            }
                        }

                        //vteszt = brigad.FirstElement.ElementValue;
                        //bteszt = brigad;
                        //Console.WriteLine("V: " + v.UniqueID);
                    }

                    handler.VersenyBrigadAdd(brigad); // A brigádot hozzáadjuk a listához.

                    //Console.WriteLine(x + " : " + brigad.FirstElement.Key);
                }

                //handler.Print();
                //Console.WriteLine("print megvót");
                //handler.VersenyzoTorolFromBrigad(bteszt, vteszt);
            }
            catch (Exception ex)
            {
                throw new FileLoadException("Hiba a brigádok file olvasásakor! " + ex);
            }
            //handler.Print();
            //handler.VersenyBrigadSort();
            //handler.Print();

            Help();
            bool Run = true;

            while (Run)
            {
                try
                {
                    string s = Console.ReadLine();
                    int    i;
                    bool   b = int.TryParse(s, out i);
                    while (!b)
                    {
                        Console.WriteLine("Hibás Opció! Listázom a lehetőségeket.");
                        Help();
                        s = Console.ReadLine();
                        b = int.TryParse(s, out i);
                    }

                    switch (i)
                    {
                    case 1:
                        handler.VersenyBrigadSort();
                        Console.WriteLine("Brigádok rendezve!");
                        break;

                    case 2:
                        Console.WriteLine("Listázás.");
                        var brigadelement = handler.FirstElement;
                        while (brigadelement != null)
                        {
                            Console.WriteLine("Brigád: " + brigadelement.ElementValue.Name + " -- első kulcsa: " + brigadelement.Key);
                            var versenyzoelement = brigadelement.ElementValue.FirstElement;
                            while (versenyzoelement != null)
                            {
                                var versenyzo = versenyzoelement.ElementValue;
                                Console.WriteLine(versenyzo.Nev + " " + versenyzo.VersenyzoAzonosito + " " + versenyzo.Lakhely);

                                if (versenyzoelement.LastElement)
                                {
                                    break;
                                }
                                versenyzoelement = versenyzoelement.NextElement;
                            }

                            Console.WriteLine();
                            brigadelement = brigadelement.NextElement;
                        }
                        break;

                    case 3:
                        Console.WriteLine("Megpróbálkozunk a versenyző versenyszámainak optimalizálásával.");
                        Console.WriteLine();

                        foreach (var x in AvailableRacesNORML)
                        {
                            Console.Write(x.Megnevezes + "\t");
                        }

                        Console.WriteLine();
                        try
                        {
                            handler.VersenyBrigadBeosztasKiir(AvailableRaces);
                        }
                        catch (BTSException ex)
                        {
                            Console.WriteLine("Hiba: " + ex.Message);
                        }
                        Console.WriteLine();
                        break;

                    case 4:
                        Console.WriteLine("Írjál be egy azonosítót.");
                        string id = Console.ReadLine();

                        Versenyzo v = handler.AlertRemoval(id);
                        if (v != null)
                        {
                            if (NParticipates != null)
                            {
                                NParticipates(v);
                            }
                            handler.VersenyzoTorol(v);
                            Console.WriteLine("Törlés megtörtént!");
                        }
                        else
                        {
                            Console.WriteLine("Nem található!");
                        }
                        break;

                    case 5:
                        Console.WriteLine("Írjál be egy brigád nevet.");
                        string name = Console.ReadLine();

                        bool b3 = handler.VersenyBrigadDelete(name);
                        if (b3)
                        {
                            Console.WriteLine("Törlés megtörtént!");
                        }
                        else
                        {
                            Console.WriteLine("Nem található!");
                        }
                        break;

                    case 6:
                        Run = false;
                        break;
                    }
                    Console.WriteLine("Folytatáshoz nyomj meg egy billenytű gombot.");
                    Console.ReadKey();
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Hibás bevitel, vagy valami kritikus hiba történt! " + ex);
                }
            }

            //Console.ReadKey();
        }
コード例 #11
0
 private bool Fk(Versenyzo[] eredmenyek, Versenyzo v, int szint)
 {
     return(true);
 }
コード例 #12
0
 private bool Ft(int szint, Versenyzo v)
 {
     return(v.TerhelHetoMeg());
 }
コード例 #13
0
 public ListElement(TourdeNIK.Versenyzo val)
 {
     this.ElementValue = val;
     this.Key          = val.UniqueID;
 }
コード例 #14
0
ファイル: VersenyzoKezelo.cs プロジェクト: dretax/TourdeNIK
 /// <summary>
 /// Hozzáadja a versenyzőt a specifikus brigádhoz.
 /// </summary>
 /// <param name="b"></param>
 /// <param name="v"></param>
 public void VersenyzoHozzaAdd(VersenyBrigad b, Versenyzo v)
 {
     b.AddInSortedWay(v);
 }