public void NumberReturnsFactors(string number, string output) { FactorFinder find = new FactorFinder(); string actual = find.PrintFactors(number); Assert.AreEqual(output, actual); }
private void CreateFactorFinderInstance() { int numToFactor = ConsoleInput.NumToFactor(); _finder = new FactorFinder(); _finder.FindFactors(numToFactor); }
public void Run() { int var = GetNumberFromUser(); Console.WriteLine($"The factors of {var} are: "); int countOfFactors = FactorFinder.GetFactorsCount(var); int[] foundFactors = FactorFinder.GetFactors(countOfFactors, var); Console.WriteLine($"{string.Join(", ", foundFactors)}"); if (PrimeChecker.IsPrimeNumber(var) == true) { Console.WriteLine($"{var} is PRIME"); } else { Console.WriteLine($"{var} is NOT PRIME "); } if (PerfectChecker.GetPerfectNumber(var) == true) { Console.WriteLine($"{var} is a PERFECT number!"); } else { Console.WriteLine($"{var} is NOT a PERFECT number!"); } }
public void RunProg() { ConsoleOutput.DisplayTitle(); Console.Clear(); ConsoleKeyInfo keyPressed; do { MyManager = new WorkManager(); int enteredNumber = ConsoleInput.GetNumberFromUser(); FactorFinder factorResults = MyManager.ProcessNumber(enteredNumber); ConsoleOutput.DisplayFactors(factorResults); PerfectChecker perfectResults = MyManager.ProcessPerfect(enteredNumber); ConsoleOutput.DisplayPerfect(perfectResults); PrimeChecker primeResults = MyManager.ProcessPrime(enteredNumber); ConsoleOutput.DisplayPrime(primeResults); ConsoleOutput.ContinueOrQuitMessage(); keyPressed = ConsoleInput.ContinueOrQuit(); Console.Clear(); } while (!(keyPressed.Key == ConsoleKey.Q)); }
private void Calculate() { _factors = FactorFinder.FindFactorList(_target); _factors.Add(_target); _isPrime = PrimeChecker.IsPrime(_target); _isPerfect = PerfectChecker.IsPerfect(_target); }
/// <summary> /// Solves the problem /// </summary> /// <returns></returns> public long Solve() { Stopwatch sw = new Stopwatch(); sw.Start(); long num = ConsecNumbers[this.Size - 1].Key; FactorFinder f; while (!HasSameConsecutives) { try { num++; // Console.WriteLine(num); f = new FactorFinder(num); f.FindPrimes(pReader.SmallerThan(num + 1)); MoveArray(num, f.Primes.Keys.Count); } catch (Exception) { } } sw.Stop(); Console.WriteLine("Elapsed: {0}s, {1}ms", sw.Elapsed.Seconds, sw.Elapsed.Milliseconds); return(ConsecNumbers[0].Key); }
public static void DisplayFactors(FactorFinder value) { string factors = ""; factors = string.Join(", ", value.Factors); Console.WriteLine($"The factors of {value.GetMyNumber()} are: {factors} "); }
public void Factorize() { Manager = new LogicManager(); int numberToFactor = ConsoleInput.GetNumberFromUser(); FactorFinder factorResults = Manager.CalculateFactors(numberToFactor); }
public void StartProgram() { int[] arrFactor; ConsoleOutput consoleOutput = new ConsoleOutput(); ConsoleInput consoleInput = new ConsoleInput(); FactorFinder factorFinder = new FactorFinder(); PerfectChecker perfectChecker = new PerfectChecker(); PrimeChecker primeChecker = new PrimeChecker(); consoleOutput.OutputMessage("Which number Do you want to factor: "); consoleInput.UserInput = int.Parse(Console.ReadLine()); arrFactor = factorFinder.FactorArray(consoleInput.UserInput); consoleOutput.OutputMessage("The Factors are: \n"); consoleOutput.StringJoinArray(arrFactor); if (perfectChecker.PerfectNumber(consoleInput.UserInput)) { consoleOutput.OutputMessage($"{consoleInput.UserInput} is a Perfect Number. \n"); } else { consoleOutput.OutputMessage($"{consoleInput.UserInput} is NOT a Perfect Number. \n"); } if (primeChecker.PrimeNumber(consoleInput.UserInput)) { consoleOutput.OutputMessage($"{consoleInput.UserInput} is a Prime Number. \n"); } else { consoleOutput.OutputMessage($"{consoleInput.UserInput} is NOT a Prime Number.\n"); } Console.ReadKey(); }
public void FactorFinderTest(int number, int[] expected) { FactorFinder ff = new FactorFinder(); int[] actual = ff.GetFactors2(number); Assert.AreEqual(expected, actual); }
public void Start() { FactorFinder ff = new FactorFinder(); int num = InputClass.GetIntFromUser("Enter number to process"); int[] factors = ff.GetFactors(num); OutputClass.SentToConsole($"\nThe factors of {num} are as follows:\n"); for (int i = 0; i < factors.Length; i++) { OutputClass.SentToConsole($"{factors[i]}"); } if (PerfectChecker.IsItPerfect(factors)) { OutputClass.SentToConsole($"\n{num} is a perfect number!"); } else { OutputClass.SentToConsole($"\n{num} is NOT a perfect number!"); } if (PrimeChecker.IsItPrime(factors)) { OutputClass.SentToConsole($"\n{num} is a prime number!"); } else { OutputClass.SentToConsole($"\n{num} is NOT a prime number!"); } OutputClass.SentToConsole("\nPress any key to end."); Console.ReadKey(); }
public void TestFactorArray(int x, int[] expected) { FactorFinder findFactor = new FactorFinder(); int[] result = findFactor.FactorArray(x); Assert.AreEqual(expected, result); }
public void FactorFinderTests(int x, int[] expected) { FactorFinder factors = new FactorFinder(); int[] result = factors.FactorArray(x); Assert.AreEqual(expected, result); }
public void StartFactoring() { var num = Input.GetNumberFromUser(); // get # from user var factors = FactorFinder.FactFinder(num); // get factor var prime = PrimeChecker.Prime(factors); // is prime var perfect = PerfectChecker.Perfect(factors, num); // is perfect Output.Results(num, factors, prime, perfect); // send results to Output.cs }
public void FactorFinderTest1() { FactorFinder ff = new FactorFinder(); List <int> actual = ff.GetFactors(120); Assert.AreEqual(new List <int> { 1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 20, 24, 30, 40, 60, 120 }, actual); }
public void FactorFinderTest4() { FactorFinder ff = new FactorFinder(); List <int> actual = ff.GetFactors(0); Assert.AreEqual(new List <int> { 0 }, actual); }
public void TestFindFactorials() { var finder = new FactorFinder(); Assert.That(finder.FindFactors(0), Is.EqualTo(new int[] {})); Assert.That(finder.FindFactors(5), Is.EqualTo(new[] { 1 })); Assert.That(finder.FindFactors(11), Is.EqualTo(new[] { 1 })); Assert.That(finder.FindFactors(12), Is.EqualTo(new[] { 1, 2, 3, 4, 6 })); Assert.That(finder.FindFactors(81), Is.EqualTo(new[] { 1, 3, 9, 27 })); Assert.That(finder.FindFactors(144), Is.EqualTo(new[] { 1, 2, 3, 4, 6, 8, 9, 12, 16, 18, 24, 36, 48, 72 })); }
public void TestFindPossibleSums() { var factorFinder = new FactorFinder(); var abundantNumberFinder = new AbundantNumberFinder(factorFinder); var collator = new SumCollator(); var possibleSumsFinder = new PossibleSumsFinder(abundantNumberFinder, collator); Assert.That(possibleSumsFinder.FindSumsForAbundantNumbers(0), Is.EqualTo(new int[] {})); Assert.That(possibleSumsFinder.FindSumsForAbundantNumbers(1), Is.EqualTo(new int[] {})); Assert.That(possibleSumsFinder.FindSumsForAbundantNumbers(25), Is.EqualTo(new[] { 24, 30, 32, 36, 36, 38, 40, 42, 44, 48 })); }
public void TestExecute() { var factorFinder = new FactorFinder(); var finder = new AbundantNumberFinder(factorFinder); Assert.That(finder.Check(0), Is.False); Assert.That(finder.Check(1), Is.False); Assert.That(finder.Check(11), Is.False); Assert.That(finder.Check(12), Is.True); Assert.That(finder.Check(13), Is.False); }
private static void ExecuteProblem23(int max) { var collator = new SumCollator(); var factorFinder = new FactorFinder(); var abundantNumberFinder = new AbundantNumberFinder(factorFinder); var valueCounter = new FinalValueCounter(); var possibleSumFinder = new PossibleSumsFinder(abundantNumberFinder, collator); var mysteryNumberFinder = new MysteryNumberFinder(possibleSumFinder); var problem23Runner = new Problem23Runner(mysteryNumberFinder, valueCounter); Console.WriteLine(problem23Runner.Execute(max)); }
public void Puzzle_1B() { var input = PuzzleInputs.Puzzle1; var finder = new FactorFinder { Candidates = input }; var result = finder.FindThreeCandidatesThatSumTo(2020).ToArray(); Assert.Equal(2020, result[0] + result[1] + result[2]); Assert.Equal(1, result[0] * result[1] * result[2]); }
/// <summary> /// Creates a new problem /// </summary> /// <param name="consecSize">The size of consec numbers</param> public DistinctPrimesFactors(int consecSize = 4) { ConsecNumbers = new KeyValuePair <long, int> [consecSize]; this.Size = consecSize; FactorFinder f; pReader = new PrimeFileReader(new FileInfo(Path.Combine(PRIME_PATH, PRIME_FILE)), new long[] { 0, 10000000 }); for (int i = 0; i < consecSize; i++) { f = new FactorFinder(i + 1); f.FindPrimes(pReader.SmallerThan(i + 2)); ConsecNumbers[i] = new KeyValuePair <long, int>(i + 1, f.Primes.Keys.Count); } }
//the workflow should invoke methods to perform tasks. //It should not contain any calculations. public void Run() { Console.WriteLine("Welcome to Factorizer"); do { Console.WriteLine("Please enter an integer: "); int number = ConsoleInput.AwaitUserInput(); Console.WriteLine(); ConsoleOutput.ReportFactors(number, FactorFinder.GetFactors(number)); ConsoleOutput.ReportAttribte(number, PrimeChecker.isPrime(number), "prime"); ConsoleOutput.ReportAttribte(number, PerfectChecker.isPerfect(number), "prefect"); Console.WriteLine("Press ESC to quit or any kep to continue"); } while (!ConsoleInput.UserEscapes()); }
public void FactorListTest(int target, params int[] resultList) { List <int> factors = FactorFinder.FindFactorList(target); int[] targetArray = factors.ToArray(); Assert.AreEqual(targetArray.Length, resultList.Length); if (targetArray.Length == resultList.Length) { for (int i = 0; i < targetArray.Length; i++) { Assert.AreEqual(targetArray[i], resultList[i]); } } }
public void RunFactorFinder() { ConsoleOutput.DisplayTitle(); int input = ConsoleInput.GetUserInput(); FactorFinder findFactors = new FactorFinder(); int[] factors = findFactors.FactorArray(input); PrimeChecker checkPrime = new PrimeChecker(); bool isPrime = checkPrime.IsPrime(input); PerfectChecker checkPerfect = new PerfectChecker(); bool isPerfect = checkPerfect.IsPerfect(input); ConsoleOutput.DisplayResults(input, factors, isPrime, isPerfect); }
public void Should_find_candidates_that_sum_to_given_target() { var finder = new FactorFinder { Candidates = new[] { 1721, 979, 366, 299, 675, 1456 } }; var result = finder.FindTwoCandidatesThatSumTo(2020).ToList(); Assert.Contains(1721, result); Assert.Contains(299, result); }
public void TestUsage() { var collator = new SumCollator(); var factorFinder = new FactorFinder(); var abundantNumberFinder = new AbundantNumberFinder(factorFinder); var driver = new PossibleSumsFinder(abundantNumberFinder, collator); var runner = new MysteryNumberFinder(driver); var result = runner.Execute(24); Assert.That(runner.Execute(24), Is.EqualTo(new [] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 })); Assert.That(runner.Execute(25), Is.EqualTo(new [] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 })); Assert.That(runner.Execute(36), Is.EqualTo(new [] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 25, 26, 27, 28, 29, 31, 33, 34, 35 })); Assert.That(runner.Execute(0), Is.EqualTo(new int[] {})); Assert.That(runner.Execute(1), Is.EqualTo(new [] { 0 })); }
public void TestUsage() { var collator = new SumCollator(); var valueCounter = new FinalValueCounter(); var factorFinder = new FactorFinder(); var abundantNumberFinder = new AbundantNumberFinder(factorFinder); var possibleSumsFinder = new PossibleSumsFinder(abundantNumberFinder, collator); var mysteryNumFinder = new MysteryNumberFinder(possibleSumsFinder); var p23Runner = new Problem23Runner(mysteryNumFinder, valueCounter); Assert.That(p23Runner.Execute(0), Is.EqualTo("0")); Assert.That(p23Runner.Execute(1), Is.EqualTo("0")); Assert.That(p23Runner.Execute(2), Is.EqualTo("1")); Assert.That(p23Runner.Execute(25), Is.EqualTo("276")); Assert.That(p23Runner.Execute(36), Is.EqualTo("544")); }
/// <summary> /// Get the minimum fraction /// </summary> /// <param name="num">The numerator</param> /// <param name="den">The denominator</param> private void GetMinFraction(ref long num, ref long den) { FactorFinder f1 = new FactorFinder(num), f2 = new FactorFinder(den); f1.Find(true); f2.Find(true); double val = 1; foreach (var v in f1.Factors.Intersect(f2.Factors)) { val *= v; } num = (int)((double)num / val); den = (int)((double)den / val); }
public void Should_find_three_candidates_that_sum_to_target() { var finder = new FactorFinder { Candidates = new[] { 1721, 979, 366, 299, 675, 1456 } }; var result = finder.FindThreeCandidatesThatSumTo(2020).ToList(); Assert.Equal(3, result.Count); Assert.Contains(979, result); Assert.Contains(366, result); Assert.Contains(675, result); }