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