public int BruteForce()
        {
            var solution = new BruteForce();

            return(solution.RomanToInt(Input));
        }
예제 #2
0
        // Measure algorithms time
        private static TestResult RunAlgorithms(Dataset dataSet, int measurementCount)
        {
            Console.WriteLine("{0}: starting calculating dateset {1}", DateTime.Now, dataSet.GetFilePath());

            var csvBuilder = new StringBuilder();

            csvBuilder.AppendLine(TestResultHelper.GetInstanceResultHeader());

            var stopwatch = new Stopwatch();

            double BFTotal    = 0;
            double BandBTotal = 0;
            double dpTotal    = 0;

            double reduxTotal  = 0;
            double reduxErrSum = 0;
            double reduxMaxErr = 0;

            double greedyTotal  = 0;
            double greedyErrSum = 0;
            double greedyMaxErr = 0;

            double ftpasTotal = 0;

            for (int i = 1; i <= dataSet.LastInstanceId; i++)
            {
                Console.WriteLine($"{DateTime.Now}::{dataSet.Name}::{dataSet.InstanceItemsCount}::{i}");

                // Load instance and solution
                var instance = InstanceLoader.LoadInstanceAsync(dataSet, i);
                if (instance == null)
                {
                    continue;
                }

                int optimalResult = InstanceLoader.LoadSolution(dataSet, i);

                double bruteForceTimeAvg     = 0;
                double branchAndBoundTimeAvg = 0;
                double dynamicProgrammingAvg = 0;
                double greedyAvg             = 0;
                double reduxAvg = 0;

                int[] greedyHeuristicResult = null;
                int[] reduxHeuristicResult  = null;
                for (int j = 0; j < measurementCount; j++)
                {
                    stopwatch.Reset();

                    // Start Brute Force
                    stopwatch.Start();
                    var bruteForceResult = BruteForce.Solve(0, instance.Weights, instance.Prices, 0, 0, instance.MaxWeight, instance.MinPrice, new int[instance.N + 1], new int[instance.N + 1]);
                    stopwatch.Stop();

                    CheckResult(instance, bruteForceResult[instance.N], optimalResult, dataSet.Name, nameof(BruteForce));
                    bruteForceTimeAvg += stopwatch.Elapsed.TotalMilliseconds;

                    stopwatch.Reset();

                    // Start Branch and Bound
                    stopwatch.Start();
                    var branchAndBoundResult = BranchAndBound.Solve(0, instance.Weights, instance.Prices, 0, 0, instance.MaxWeight, new int[instance.N + 1], new int[instance.N + 1]);
                    //BranchAndBound.Decide(0, instance.Weights, instance.Prices, 0, 0, instance.MaxWeight, 324);
                    stopwatch.Stop();

                    CheckResult(instance, branchAndBoundResult[instance.N], optimalResult, dataSet.Name, nameof(BranchAndBound));
                    branchAndBoundTimeAvg += stopwatch.Elapsed.TotalMilliseconds;

                    stopwatch.Reset();

                    // Start Dynamic programming
                    stopwatch.Start();
                    var dynamicProgrammingResult = DynamicProgramming.Solve(instance.Items, instance.MaxWeight);
                    stopwatch.Stop();

                    CheckResult(instance, dynamicProgrammingResult[instance.N], optimalResult, dataSet.Name, nameof(DynamicProgramming));
                    dynamicProgrammingAvg += stopwatch.Elapsed.TotalMilliseconds;

                    stopwatch.Reset();

                    // Start Greedy heuristic
                    stopwatch.Start();
                    greedyHeuristicResult = GreedyHeuristic.Solve(instance.Items.ToList(), instance.MaxWeight);
                    stopwatch.Stop();

                    //CheckResult(instance, greedyHeuristicResult[instance.N], optimalPrice, dataSet.Name, nameof(GreedyHeuristic));
                    greedyAvg += stopwatch.Elapsed.TotalMilliseconds;

                    stopwatch.Reset();

                    // Start Redux heuristic
                    stopwatch.Start();
                    reduxHeuristicResult = ReduxHeuristic.Solve(instance.Items.ToList(), instance.MaxWeight);
                    stopwatch.Stop();

                    reduxAvg += stopwatch.Elapsed.TotalMilliseconds;

                    stopwatch.Reset();
                }

                BFTotal     += Avg(bruteForceTimeAvg, measurementCount);
                BandBTotal  += Avg(branchAndBoundTimeAvg, measurementCount);
                dpTotal     += Avg(dynamicProgrammingAvg, measurementCount);
                greedyTotal += Avg(greedyAvg, measurementCount);
                reduxTotal  += Avg(reduxAvg, measurementCount);

                csvBuilder.AppendLine(TestResultHelper.FormatInstanceResultRow(
                                          instance.Id,
                                          instance.N,
                                          Avg(bruteForceTimeAvg, measurementCount),
                                          Avg(branchAndBoundTimeAvg, measurementCount),
                                          Avg(dynamicProgrammingAvg, measurementCount),
                                          Avg(greedyAvg, measurementCount),
                                          Avg(reduxAvg, measurementCount),
                                          0
                                          ));
            }

            Console.WriteLine("{0}: calculating dataset {1} ended", DateTime.Now, dataSet.GetFilePath());

            return(new TestResult
            {
                InstanceSize = dataSet.InstanceItemsCount,
                InstancesResults = csvBuilder.ToString(),
                BFTime = Avg(BFTotal, dataSet.InstancesCount),
                BandBTime = Avg(BandBTotal, dataSet.InstancesCount),
                GreedyHeuristicTime = Avg(greedyTotal, dataSet.InstancesCount),
                ReduxHeuristicTime = Avg(reduxTotal, dataSet.InstancesCount),
                DPTime = Avg(dpTotal, dataSet.InstancesCount),
                FTPASTime = Avg(ftpasTotal, dataSet.InstancesCount),

                GreedyRelErr = Avg(greedyErrSum, dataSet.InstancesCount),
                GreedyMaxErr = greedyMaxErr,
                ReduxRelErr = Avg(reduxErrSum, dataSet.InstancesCount),
                ReduxMaxErr = reduxMaxErr
            });
        }
        static void Main(string[] args)
        {
            Logger.WriteLine("String Pattern Matching");

            // Variable to hold whether or not to continue the program after each termination
            string keepPlaying;

            // Loop while the user wants to continue
            do
            {
                // Get user input of text, pattern, and which algorithm to run
                var(text, pattern, algorithm) = GetUserInput();

                // Run one algorithm if user did not specify to run all
                if (algorithm != "all" && algorithm != "ALL")
                {
                    // Get the index and comparisons based on which algorithm the user chose
                    var(index, comparisons) = algorithm switch
                    {
                        var x when x == "BF" || x == "bf" => BruteForce.Run(text, pattern),
                        var y when y == "BMH" || y == "bmh" => BMH.Run(text, pattern),
                        var z when z == "BM" || z == "bm" => BM.Run(text, pattern),
                        _ => throw new Exception("Invalid algorithm string"),
                    };

                    // If the pattern was not found
                    if (index == -1)
                    {
                        Logger.Write("\nPattern was not found in the given text. ");
                    }
                    // Else the pattern was found
                    else
                    {
                        Logger.Write($"\nPattern was found at index {index}. ");
                    }

                    Logger.WriteLine($"There were {comparisons} comparisons made.");
                }
                else
                {
                    // Get the index and comparisons from all algorithms
                    var(indexBF, comparisonsBF)   = BruteForce.Run(text, pattern);
                    var(indexBMH, comparisonsBMH) = BMH.Run(text, pattern);
                    var(indexBM, comparisonsBM)   = BM.Run(text, pattern);

                    // All algorithms should return the same index so we only need to use indexBF

                    // If pattern was not found
                    if (indexBF == -1)
                    {
                        Logger.WriteLine("\nPattern was not found in the given text. ");
                    }
                    // Else pattern was found
                    else
                    {
                        Logger.WriteLine($"\nPattern was found at index {indexBF}. ");
                    }

                    Logger.WriteLine($"There were {comparisonsBF} comparisons made by the Brute Force Algorithm.");
                    Logger.WriteLine($"There were {comparisonsBMH} comparisons made by the Boyer-Moore-Horspool Algorithm.");
                    Logger.WriteLine($"There were {comparisonsBM} comparisons made by the Boyer-Moore Algorithm.");
                }

                // Loop until valid input of y/n
                do
                {
                    Logger.WriteLine("\nWould you like to repeat program? y/n ");
                    keepPlaying = Logger.ReadLine();
                }while (keepPlaying != "y" && keepPlaying != "Y" && keepPlaying != "n" && keepPlaying != "N");

                Logger.WriteLine();
            }while (keepPlaying == "y" || keepPlaying == "Y");

            Logger.LogToFile();

            Console.WriteLine("\nLog outputted to logs/ directory.");

            Console.WriteLine("\nPress enter to exit...");
            Console.ReadLine();
        }
예제 #4
0
        /**
         * Frecuency of occurrence of an itemset: Counts in how many transactions a given itemset occurs.
         * itemset : Array of codes of a itemset.
         **/
        public int SupportCount(int[] itemset)
        {
            List <List <int> > dataBase = context.Transactions.Select(t => t.Value.Items).ToList();

            return(BruteForce.SupportCount(itemset, dataBase));
        }