public override long Solve()
{
int longestNumberOfAddends = 0;
long primeWithLongestSumOfConsecutivePrimes = 0;
var primes = Primes.CalculatePrimesBelow(primeBelow);
var maxPrime = primes.Last();
for (int primeIndex = 0; primeIndex < primes.Count; primeIndex++)
{
int numberOfAddends = 0;
long sum = 0;
for (int i = primeIndex; i < primes.Count; i++)
{
sum += primes.ElementAt(i);
numberOfAddends++;
if (primes.Contains(sum) && numberOfAddends > longestNumberOfAddends)
{
longestNumberOfAddends = numberOfAddends;
primeWithLongestSumOfConsecutivePrimes = sum;
}
if (sum > maxPrime)
{
break;
}
}
}
return(primeWithLongestSumOfConsecutivePrimes);
}
public override long Solve()
{
var bRange = Primes.CalculatePrimesBelow(MAX_COEFF);
var aRange = Enumerable.Range(-999, 1999);
long maxPrimesCount = 0;
long maxACoeff = 0;
long maxBCoeff = 0;
foreach (var b in bRange)
{
foreach (var a in aRange)
{
long n = 0;
while (Primes.IsPrime((n * n) + (a * n) + b))
{
n++;
}
if (n > maxPrimesCount)
{
maxPrimesCount = n;
maxACoeff = a;
maxBCoeff = b;
}
}
}
return(maxACoeff * maxBCoeff);
}
public override long Solve()
{
var primesBelow = 10000;
var primes = Primes.CalculatePrimesBelow(primesBelow);
var oddComposites = BuildOddComposites(primes);
foreach (var oddComposite in oddComposites)
{
var found = false;
for (int i = 0; i < primes.Count && primes.ElementAt(i) < oddComposite && !found; i++)
{
int numberToBeSquared = 1;
while (oddComposite > Math.Abs((numberToBeSquared * numberToBeSquared * 2) - primes.ElementAt(i)))
{
if (oddComposite == primes.ElementAt(i) + (2 * numberToBeSquared * numberToBeSquared))
{
found = true;
}
numberToBeSquared++;
}
}
if (!found)
{
return(oddComposite);
}
}
throw new Exception("Could not find an odd composite below " + primesBelow);
}
public static HashSet <long> CalculateDistinctPrimeFactorsSLOW(int number)
{
var primes = Primes.CalculatePrimesBelow(number + 1);
var primeFactors = new HashSet <long>();
return(PrimeFactors(number, primes, primeFactors));
}
public override long Solve()
{
long circularPrimeCount = 0;
var primesLookup = Primes.CalculatePrimesBelow(max);
foreach (var prime in primesLookup)
{
if (PossibleCircularPrime(prime))
{
var rotations = Permutations.GenerateNumberRotations(prime);
if (rotations.All(p => primesLookup.Contains(p)))
{
circularPrimeCount++;
}
}
}
return(circularPrimeCount);
}
//http://en.wikipedia.org/wiki/Truncatable_prime
public override long Solve()
{
long sum = 0;
var primes = Primes.CalculatePrimesBelow(1000000);
foreach (var prime in primes)
{
bool truncatable = true;
if (PossibleTruncatablePrime(prime))
{
var leftToRightTruncate = new Truncate(prime, TruncateMethod.LeftToRight);
while (leftToRightTruncate.CanTruncate())
{
if (!primes.Contains(leftToRightTruncate.NextValue()))
{
truncatable = false;
break;
}
}
var rightToLeftTruncate = new Truncate(prime, TruncateMethod.RightToLeft);
while (rightToLeftTruncate.CanTruncate())
{
if (!primes.Contains(rightToLeftTruncate.NextValue()))
{
truncatable = false;
break;
}
}
if (truncatable)
{
sum += prime;
}
}
}
return(sum);
}
//12.5 seconds without filtering out invalid pandigitals.
//filtering inputs:
//Filter out pandigitals where d6 is not divisble by 5: 11.4 seconds
public override long Solve()
{
var primes = Primes.CalculatePrimesBelow(18).ToArray();
var pandigitals = Pandigitals.GenerateZeroToN(9);
long sum = 0;
foreach (var pandigital in pandigitals)
{
if (PossibleSubstringDivisibleByPrime(pandigital))
{
var divisibleByPrime = true;
for (int i = 0; i < primes.Length && divisibleByPrime; i++)
{
divisibleByPrime = SubstringDivisibleBy(pandigital, i + 1, primes[i]);
}
if (divisibleByPrime)
{
sum += pandigital;
}
}
}
return(sum);
}
public Problem51(int primeFamily)
{
this.primeFamily = primeFamily;
primes = Primes.CalculatePrimesBelow(999999);
}
public Problem26(int maxDenominator)
{
this.maxDenominator = maxDenominator;
primes = Primes.CalculatePrimesBelow(maxDenominator);
}
public override long Solve()
{
return(Primes.CalculatePrimesBelow(primesBelow).Sum());
}
public override long Solve()
{
long smallestSum = 0;
var primes = Primes.CalculatePrimesBelow(10000);
foreach (var first in primes)
{
foreach (var second in primes)
{
if (second <= first)
{
continue;
}
if (Primes.IsPrime(Concat(first, second)) && Primes.IsPrime(Concat(second, first)))
{
foreach (var third in primes)
{
if (third <= second)
{
continue;
}
if (Primes.IsPrime(Concat(first, third)) && Primes.IsPrime(Concat(third, first)) &&
Primes.IsPrime(Concat(second, third)) && Primes.IsPrime(Concat(third, second)))
{
foreach (var fourth in primes)
{
if (fourth <= third)
{
continue;
}
if (Primes.IsPrime(Concat(first, fourth)) && Primes.IsPrime(Concat(fourth, first)) &&
Primes.IsPrime(Concat(second, fourth)) && Primes.IsPrime(Concat(fourth, second)) &&
Primes.IsPrime(Concat(third, fourth)) && Primes.IsPrime(Concat(fourth, third)))
{
foreach (var fifth in primes)
{
if (fifth <= fourth)
{
continue;
}
if (Primes.IsPrime(Concat(first, fifth)) && Primes.IsPrime(Concat(fifth, first)) &&
Primes.IsPrime(Concat(second, fifth)) && Primes.IsPrime(Concat(fifth, second)) &&
Primes.IsPrime(Concat(third, fifth)) && Primes.IsPrime(Concat(fifth, third)) &&
Primes.IsPrime(Concat(fourth, fifth)) && Primes.IsPrime(Concat(fifth, fourth)))
{
Console.WriteLine("1: {0} 2: {1} 3: {2} 4: {3} 5: {4}", first, second, third, fourth, fifth);
var sum = new List <long> {
first, second, third, fourth, fifth
}.Sum();
if (sum < smallestSum || smallestSum == 0)
{
smallestSum = sum;
}
}
}
}
}
}
}
}
}
}
return(smallestSum);
}
