示例#1
0
        public void Menu()
        {
            bool exit = false;

            while (!exit)
            {
                Console.WriteLine($"\t\t\tGraph Menu\n" +
                                  $"\t1.Input Graph\n" +
                                  $"\t2.Output Graph\n" +
                                  $"\t3.SearchOfShortestPath(Deijkstra)\n" +
                                  $"\t4.BreadthFirstSearch\n" +
                                  $"\t5.DepthFirstSearch\n" +
                                  $"\t6.InputFromFile\n" +
                                  $"\t7.OutputInFile\n" +
                                  $"\t8.IsGraphDictyledonous\n" +
                                  $"\t9.Close road\n" +
                                  $"\tAnother.Exit\n");

                var keyInfo = Console.ReadKey();

                Console.WriteLine();

                switch (keyInfo.Key)
                {
                case ConsoleKey.D1:
                    InputOfGraph.Invoke(this, EventArgs.Empty);
                    break;

                case ConsoleKey.D2:
                    OutputOfGraph.Invoke(this, EventArgs.Empty);
                    break;

                case ConsoleKey.D3:
                    SearchOfPath.Invoke(this, EventArgs.Empty);
                    break;

                case ConsoleKey.D4:
                    BreadthFirstSearch.Invoke(this, EventArgs.Empty);
                    break;

                case ConsoleKey.D5:
                    DepthFirstSearch.Invoke(this, EventArgs.Empty);
                    break;

                case ConsoleKey.D6:
                    InputFromFile.Invoke(this, EventArgs.Empty);
                    break;

                case ConsoleKey.D7:
                    OutputInFile.Invoke(this, EventArgs.Empty);
                    break;

                case ConsoleKey.D8:
                    IsGraphDictyledonous.Invoke(this, EventArgs.Empty);
                    break;

                case ConsoleKey.D9:
                    IsRoadsClosed.Invoke(this, EventArgs.Empty);
                    break;

                default:
                    exit = true;
                    break;
                }

                Console.ReadKey();

                Console.Clear();
            }
        }
示例#2
0
        /// <summary>
        /// funktioniert nur in geordneten listen
        /// ansatzpkt für erweiterungen wäre diese beschräünkung aufzuheben 
        /// aus mangel an idee muss es erstmal so bleiben 
        /// </summary>
        /// <returns></returns>
        public ISubRoot execute()
        {
            // und mal wieder schmeißt mir irgendwer die zahlen raus
            // na wer wills diesmal sein ?!

            int TrackCount = SubRoot.Leafs.Count;

            List<Container> data = new List<Container>();

            for (int i = 0; i < SubRoot.Leafs.Count; i++)
            {
                foreach (var item in getAllNumbersInStringManager(SubRoot.Leafs[i].StringManager.RawDataParts))
                {
                    data.Add(new Container(i, item.Value, item.Key));
                }
            }

            // jetzt ein join und alle die überbleiben sind verdächtig
            // aber was ist mit den doppelten ?!
            // ein lied in dem die 2 und die 4 drin ist
            // wurde dann 2 mal matchen

            // immernoch die frage woher weiß ich elches der track its ?
            // sortieren aber wonach ?
            // halt das ist gut

            // sortieren und dann mit der enum liste abgleichen
            // ist das nicht ein db sync problem ?
            // so rein von der struktur ?
            // iteriere beide listen und controlliere welches zuviel , zuwenig, anders ist

            int AllNumbersCount = data.Count();

            OutputInFile file = new OutputInFile();

            // nur dann hab ich nen problem denn nur dann sind mehr zahlen da als tracks
            if (AllNumbersCount > TrackCount)
            {
                TracksDone = false;

                var allSortedNumbers = data.OrderBy(c => c.FoundValue).Select(c => c).ToList();
                //file.WriteStringToFile(ConvertListToString(allSortedNumbers));

                // ich muss die kleinere liste durchgehen und suchen welche in der großen doppelt drin sind
                // am ende brauch ich ne liste von allen datensätzen die nicht zugeordnet werden konnten
                // weil doppelt oder nicht vorhanden
                // nicht vorhanden ist unwahrscheinlich
                // also nur die doppelten to

                var grps = (from d in data
                            group d by d.FoundIn into grp
                            select grp).ToList();

                //file.WriteStringToFile(ConvertGrpToString(grps));

                List<Container> Result = new List<Container>();
                // iteriere über die gruppierung
                for (int i = 0; i < grps.Count; i++)
                {
                    // wenn es nur eine einzige zahl gibt ist alles cool
                    if (grps[i].Count() == 1)
                    {
                        var blub = grps[i].First();
                        Container con = new Container(blub.FoundIn, blub.FoundAt, blub.FoundValue);
                        con.UseThis = true;
                        Result.Add(con);
                        //grps.RemoveAt(i);
                        //i--;
                    }
                    else // hier kommt der fiese teil
                    {
                        // woher weiß ich welche zahl besser passt ?
                        // die zahlen sind doch geordnet
                        // dh vlt geben mir ja die tracks davor und danach information

                        // sonder fälle ...
                        // anfang
                        // ende
                        // doppelt nicht gefunden
                        foreach (var item in grps[i])
                        {

                            // kontrolliere jede dieser verdammten zahlen ob sie in davor oder danach reinpasst
                            // ich fang bei 0 an das ist kritisch
                            // ich nehme die zahl davor und danach und schau mir an ob die in der grp dabei ist

                            // gibt es eine lösung die nicht auf ordnung funktioniert ?
                            // kann es nicht geben denn ich will eine ordnung erzeugen und das was da ist ist mein einziger anhaltspunkt

                            // nimm die durchschnitts lösung eine andere gibt es nicht
                            // bzw fällt mir keine ein
                            // das würde aber doch bedeuten das I die zahl ist die ich suche ?

                            if(item.FoundValue == i + 1)
                            {
                                item.UseThis = true;
                                Result.Add(item);
                                break;
                            }

                        }
                    }
                }
                data = Result;
            }
            else
            {
                TracksDone = true;
                data.ForEach(c => c.UseThis = true);
            }
            ExecuteFoundTracks(data);

            return SubRoot;
        }