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);
}
