public void PrimeDeciders_AgreeWithKnownOutput() { var sieveDecider = new SieveOfEratosthenesDecider(2); var sieveProvider = new SieveOfEratosthenesProvider(2); var sieveFactorizer = new SieveOfEratosthenesFactorizer(2); var trialDivisionDecider = new TrialDivisionDecider(2); for (int n = 0; n <= 2; ++n) { Assert.AreEqual(_primesUpTo2.Contains(n), sieveDecider.IsPrime(n)); Assert.AreEqual(_primesUpTo2.Contains(n), sieveProvider.IsPrime(n)); Assert.AreEqual(_primesUpTo2.Contains(n), sieveFactorizer.IsPrime(n)); Assert.AreEqual(_primesUpTo2.Contains(n), trialDivisionDecider.IsPrime(n)); Assert.AreEqual(_primesUpTo2.Contains(n), NaivePrimeDeciderProviderFactorizer.IsPrime(n)); } sieveDecider = new SieveOfEratosthenesDecider(49); sieveProvider = new SieveOfEratosthenesProvider(49); sieveFactorizer = new SieveOfEratosthenesFactorizer(49); trialDivisionDecider = new TrialDivisionDecider(49); for (int n = 0; n <= 49; ++n) { Assert.AreEqual(_primesUpTo49.Contains(n), sieveDecider.IsPrime(n)); Assert.AreEqual(_primesUpTo49.Contains(n), sieveProvider.IsPrime(n)); Assert.AreEqual(_primesUpTo49.Contains(n), sieveFactorizer.IsPrime(n)); Assert.AreEqual(_primesUpTo49.Contains(n), trialDivisionDecider.IsPrime(n)); Assert.AreEqual(_primesUpTo49.Contains(n), NaivePrimeDeciderProviderFactorizer.IsPrime(n)); } }
private void SieveOfEratosthenesDecider(int limit, int passes, int start, int end) { var decider = new SieveOfEratosthenesDecider(limit); for (int p = 0; p < passes; ++p) { for (int n = start; n <= end; ++n) { decider.IsPrime(n); } } }
static PPATH() { // 10000 because zero-based indices. This isn't great as we don't need 10000 // (as most #s don't represent primes), but hopefully it doesn't matter. Edges // exist between primes (a vertex whose index is prime) and other primes, // when there's a one-digit swap to go between them (swaps are reversible). _primeGraph = new SimpleGraph(10000); var primeDecider = new SieveOfEratosthenesDecider(9999); // If n is a prime, connect to the primes greater than it, within a one-digit swap. Only // greater than because lesser primes were already connected to it earlier in the loop. for (int n = 1001; n <= 9999; n += 2) { if (!primeDecider.IsOddPrime(n)) continue; int nSwapped = n + 1000; while (nSwapped % 10000 > n) { if (primeDecider.IsOddPrime(nSwapped)) _primeGraph.AddEdge(n, nSwapped); nSwapped += 1000; } nSwapped = n + 100; while (nSwapped % 1000 > n % 1000) { if (primeDecider.IsOddPrime(nSwapped)) _primeGraph.AddEdge(n, nSwapped); nSwapped += 100; } nSwapped = n + 10; while (nSwapped % 100 > n % 100) { if (primeDecider.IsOddPrime(nSwapped)) _primeGraph.AddEdge(n, nSwapped); nSwapped += 10; } nSwapped = n + 2; while (nSwapped % 10 > n % 10) { if (primeDecider.IsOddPrime(nSwapped)) _primeGraph.AddEdge(n, nSwapped); nSwapped += 2; } } }
public void PrimeDeciders_AgreeWithNaiveDecider() { for (int i = 1000; i <= 10000; i += 1000) { var sieveDecider = new SieveOfEratosthenesDecider(i); var sieveProvider = new SieveOfEratosthenesProvider(i); var sieveFactorizer = new SieveOfEratosthenesFactorizer(i); var trialDivisionDecider = new TrialDivisionDecider(i); for (int n = 0; n <= i; ++n) { Assert.AreEqual(NaivePrimeDeciderProviderFactorizer.IsPrime(n), sieveDecider.IsPrime(n)); Assert.AreEqual(NaivePrimeDeciderProviderFactorizer.IsPrime(n), sieveProvider.IsPrime(n)); Assert.AreEqual(NaivePrimeDeciderProviderFactorizer.IsPrime(n), sieveFactorizer.IsPrime(n)); Assert.AreEqual(NaivePrimeDeciderProviderFactorizer.IsPrime(n), trialDivisionDecider.IsPrime(n)); } } }
public SieveOfEratosthenesProvider(int limit) { Limit = limit; _decider = new SieveOfEratosthenesDecider(Limit); var primes = 2 <= Limit ? new List <int> { 2 } : new List <int>(); for (int n = 3; n <= Limit; n += 2) { if (IsOddPrime(n)) { primes.Add(n); } } Primes = primes.AsReadOnly(); }
public static string Solve() { var decider = new SieveOfEratosthenesDecider(_100Million); var output = new StringBuilder(); output.Append(2); output.AppendLine(); int count = 1; for (int n = 3; n <= _100Million; n += 2) { if (decider.IsOddPrime(n) && ++count == 101) { output.Append(n); output.AppendLine(); count = 1; } } return output.ToString(); }
static PPATH() { // 10000 because zero-based indices. This isn't great as we don't need 10000 // (as most #s don't represent primes), but hopefully it doesn't matter. Edges // exist between primes (a vertex whose index is prime) and other primes, // when there's a one-digit swap to go between them (swaps are reversible). _primeGraph = new SimpleGraph(10000); var primeDecider = new SieveOfEratosthenesDecider(9999); // If n is a prime, connect to the primes greater than it, within a one-digit // swap. Only greater than because lesser primes were already connected to it // earlier in the loop. for (int n = 1001; n <= 9999; n += 2) { if (!primeDecider.IsOddPrime(n)) { continue; } int nSwapped = n + 1000; while (nSwapped % 10000 > n) { if (primeDecider.IsOddPrime(nSwapped)) { _primeGraph.AddEdge(n, nSwapped); } nSwapped += 1000; } nSwapped = n + 100; while (nSwapped % 1000 > n % 1000) { if (primeDecider.IsOddPrime(nSwapped)) { _primeGraph.AddEdge(n, nSwapped); } nSwapped += 100; } nSwapped = n + 10; while (nSwapped % 100 > n % 100) { if (primeDecider.IsOddPrime(nSwapped)) { _primeGraph.AddEdge(n, nSwapped); } nSwapped += 10; } nSwapped = n + 2; while (nSwapped % 10 > n % 10) { if (primeDecider.IsOddPrime(nSwapped)) { _primeGraph.AddEdge(n, nSwapped); } nSwapped += 2; } } }
public SieveOfEratosthenesProvider(int limit) { Limit = limit; _decider = new SieveOfEratosthenesDecider(Limit); var primes = 2 <= Limit ? new List<int>() { 2 } : new List<int>(); for (int n = 3; n <= Limit; n += 2) { if (IsOddPrime(n)) { primes.Add(n); } } Primes = primes.AsReadOnly(); }