Exemple #1
0
        public void Problem8Test()
        {
            var p8  = new Problem8();
            var res = p8.GreaterProduct();

            Assert.AreEqual(res, 23514624000);
        }
        public void Test8()
        {
            var p      = new Problem8();
            var result = p.Solution1();

            Assert.Equal(23514624000, result);
        }
Exemple #3
0
        public void ParseInputTest()
        {
            var rootNode = Problem8.ParseInput(TestInput);

            Assert.AreEqual(2, rootNode.Children.Count);
            Assert.AreEqual(3, rootNode.Metadata.Count);
        }
        public void SolutionsShouldMatch(string input, int sequenceLength, long expectedValue)
        {
            var problem = new Problem8();

            var result = problem.Solve(new Problem8.Arguments(input, sequenceLength));

            Assert.AreEqual(expectedValue.ToString(), result);
        }
Exemple #5
0
        public void GetsGreatestProduct(int windowSize, long expectedResult)
        {
            var sut = new Problem8();

            var result = sut.GetGreatestProduct(windowSize);

            Assert.AreEqual(expectedResult, result);
        }
Exemple #6
0
        public void SolveTest()
        {
            Problem8 problem8 = new Problem8();

            double expected = 5832;
            double actual   = problem8.Solve(4);

            Assert.AreEqual(expected, actual);
        }
 static void Main(string[] args)
 {
     Console.WriteLine($"Problem 1: {Problem1.Solve()}");
     Console.WriteLine($"Problem 2: {Problem2.Solve()}");
     Console.WriteLine($"Problem 3: {Problem3.Solve()}");
     Console.WriteLine($"Problem 4: {Problem4.Solve()}");
     Console.WriteLine($"Problem 5: {Problem5.Solve()}");
     Console.WriteLine($"Problem 6: {Problem6.Solve()}");
     Console.WriteLine($"Problem 7: {Problem7.Solve()}");
     Console.WriteLine($"Problem 8: {Problem8.Solve()}");
     Console.WriteLine($"Problem 9: {Problem9.Solve()}");
     Console.WriteLine($"Problem 10: {Problem10.Solve()}");
 }
Exemple #8
0
        public void Test8(int a, int b, int c)
        {
            string expected = ((a + b + c) / 3f).ToString();

            using (var sw = new StringWriter())
            {
                using (var sr = new StringReader($"{a}\n{b}\n{c}"))
                {
                    Console.SetIn(sr);
                    Console.SetOut(sw);
                    Problem8.Main();
                }
                string result = sw.ToString().Trim();

                Assert.AreEqual(expected, result);
            }
        }
 public void Problem8_ShouldReturn_23514624000()
 {
     Assert.Equal(Problem8.GetResult(), 23514624000);
 }
Exemple #10
0
 public void Verify_Highest_Product_For_N_Adjacent_Number()
 {
     Assert.AreEqual(5832, Problem8.Solve(4));
     Assert.AreEqual(23514624000, Problem8.Solve(13));
 }
Exemple #11
0
        static public void Main(string[] args)
        {
            Console.WriteLine("Console App Used to Display Results of my Euler Project Code");
            Console.WriteLine("As long as the questions are simple enough, they will all show up here.");
            Console.WriteLine("------------------------------\n");

            while (!endApp)
            {
                Console.WriteLine("Option 1: Run Problem 1.");
                Console.WriteLine("Option 2: Run Problem 2.");
                Console.WriteLine("Option 3: Run Problem 3.");
                Console.WriteLine("Option 4: Run Problem 4.");
                Console.WriteLine("Option 5: Run Problem 5.");
                Console.WriteLine("Option 6: Run Problem 6.");
                Console.WriteLine("Option 7: Run Problem 7.");
                Console.WriteLine("Option 8: Run Problem 8.");
                Console.WriteLine("Option 9: Run Problem 9.");
                Console.WriteLine("\n");


                Console.Write("Press 'n' and Enter to close the app, or press # of option and Enter to continue: ");
                string caseSwitch = Console.ReadLine();

                switch (caseSwitch)
                {
                case "1":
                    Console.WriteLine("\n\nCase 1:\n\n");
                    IProblem problem1 = new Problem1();
                    problem1.PrintProblem();
                    problem1.SolveProblem();
                    problem1.PrintAnswer();
                    Console.WriteLine("------------------------------\n");
                    break;

                case "2":
                    Console.WriteLine("\n\nCase 2:\n\n");
                    IProblem problem2 = new Problem2();
                    problem2.PrintProblem();
                    problem2.SolveProblem();
                    problem2.PrintAnswer();
                    Console.WriteLine("------------------------------\n");
                    break;

                case "3":
                    Console.WriteLine("\n\nCase 3:\n\n");
                    IProblem problem3 = new Problem3();
                    problem3.PrintProblem();
                    problem3.SolveProblem();
                    problem3.PrintAnswer();
                    Console.WriteLine("------------------------------\n");
                    break;

                case "4":
                    Console.WriteLine("\n\nCase 4:\n\n");
                    IProblem problem4 = new Problem4();
                    problem4.PrintProblem();
                    problem4.SolveProblem();
                    problem4.PrintAnswer();
                    Console.WriteLine("------------------------------\n");
                    break;

                case "5":
                    Console.WriteLine("\n\nCase 5:\n\n");
                    IProblem problem5 = new Problem5();
                    problem5.PrintProblem();
                    problem5.SolveProblem();
                    problem5.PrintAnswer();
                    Console.WriteLine("------------------------------\n");
                    break;

                case "6":
                    Console.WriteLine("\n\nCase 6:\n\n");
                    IProblem problem6 = new Problem6();
                    problem6.PrintProblem();
                    problem6.SolveProblem();
                    problem6.PrintAnswer();
                    Console.WriteLine("------------------------------\n");
                    break;

                case "7":
                    Console.WriteLine("\n\nCase 7:\n\n");
                    IProblem problem7 = new Problem7();
                    problem7.PrintProblem();
                    problem7.SolveProblem();
                    problem7.PrintAnswer();
                    Console.WriteLine("------------------------------\n");
                    break;

                case "8":
                    Console.WriteLine("\n\nCase 8:\n\n");
                    IProblem problem8 = new Problem8();
                    problem8.PrintProblem();
                    problem8.SolveProblem();
                    problem8.PrintAnswer();
                    Console.WriteLine("------------------------------\n");
                    break;

                case "9":
                    Console.WriteLine("\n\nCase 9:\n\n");
                    IProblem problem9 = new Problem9();
                    problem9.PrintProblem();
                    problem9.SolveProblem();
                    problem9.PrintAnswer();
                    Console.WriteLine("------------------------------\n");
                    break;

                case "10":
                    var reader = new PokerHandsReader();
                    reader.PrintLines();
                    break;

                case "n":
                    endApp = true;
                    break;

                default:
                    Console.WriteLine("Not an option.");
                    Console.Write("Press 'n' and Enter to close the app, or press any other key and Enter to continue: ");
                    break;
                }
            }
            return;
        }
Exemple #12
0
 public void TestProblem8(int digits, long expected)
 {
     Assert.AreEqual(expected, Problem8.FindAdjacentProduct(digits));
 }
Exemple #13
0
 public void FindAccumulatorValueAfterModification()
 {
     Assert.AreEqual(8, Problem8.FindAccumulatorValueAfterModification(_testInput));
 }
Exemple #14
0
 public void FindAccumulatorValueAfterExecution()
 {
     Assert.AreEqual(5, Problem8.FindAccumulatorValueOnRepeat(_testInput));
 }
Exemple #15
0
        public void FindValueTest()
        {
            var rootNode = Problem8.ParseInput(TestInput);

            Assert.AreEqual(66, Problem8.FindValue(rootNode));
        }
Exemple #16
0
        public void FindMetadataSumTest()
        {
            var rootNode = Problem8.ParseInput(TestInput);

            Assert.AreEqual(138, Problem8.FindMetadataSum(rootNode));
        }