public override long Solution()
{
long number = 0;
const int upperbound = 200000;
List <int> primes = Primes.EratosthenesSieve(upperbound);
foreach (int nonPrime in ReversedEratosthenesSieve(upperbound))
{
if (number > 0)
{
break;
}
if (nonPrime % 2 != 0)
{
foreach (int prime in primes)
{
if (prime > nonPrime)
{
number = nonPrime;
break;
}
if (CanBeComposited(prime, nonPrime))
{
break;
}
}
}
}
return(number);
}
public override long Solution()
{
string result = string.Empty;
HashSet <int> primes = new HashSet <int>(Primes.EratosthenesSieve(10000));
foreach (int prime in primes)
{
if (prime < 1000)
{
continue;
}
List <string> permutations = Permutation.GetPermutations(prime.ToString());
HashSet <int> permutedPrimes = new HashSet <int>();
foreach (string permutation in permutations)
{
int number = int.Parse(permutation);
if (number > 1000 && primes.Contains(number))
{
permutedPrimes.Add(number);
}
}
int[] possiblePrimes = new int[permutedPrimes.Count];
permutedPrimes.CopyTo(possiblePrimes);
Array.Sort(possiblePrimes);
for (int i = 0; i < possiblePrimes.Length - 2; i++)
{
int firstPrime = possiblePrimes[i];
if (firstPrime == 1487)
{
continue;
}
for (int j = i + 1; j < possiblePrimes.Length - 1; j++)
{
int secondPrime = possiblePrimes[j];
for (int k = j + 1; k < possiblePrimes.Length; k++)
{
int thirdPrime = possiblePrimes[k];
if (thirdPrime - secondPrime == secondPrime - firstPrime)
{
result = string.Format("{0}{1}{2}", firstPrime, secondPrime, thirdPrime);
k = j = i = possiblePrimes.Length;
}
}
}
}
if (!string.IsNullOrEmpty(result))
{
break;
}
}
return(long.Parse(result));
}
private static long SumOfPrimes(int upperBound)
{
long sum = 0;
foreach (int primeNumber in Primes.EratosthenesSieve(upperBound))
{
sum += primeNumber;
}
return(sum);
}
private static ICollection<int> GetCircularPrimes(int upperBound)
{
ICollection<int> primes = new HashSet<int>(Primes.EratosthenesSieve(upperBound));
ICollection<int> circularPrimes = new HashSet<int>();
foreach (int primeNumber in primes)
{
// Skip numbers that have already been added as a rotation
if (!circularPrimes.Contains(primeNumber))
{
// Skip all numbers containing an even digit
string primeString = primeNumber.ToString();
if(primeNumber > 2)
{
bool canContinue = false;
foreach(char digit in primeString)
{
if(digit % 2 == 0)
{
canContinue = true;
break;
}
}
if(canContinue)
{
continue;
}
}
List<int> numbers = new List<int> { primeNumber };
int rotatedNumber = primeNumber;
for(int i = 1; i < primeString.Length; i++)
{
rotatedNumber = RotateNumber(rotatedNumber);
if (!primes.Contains(rotatedNumber))
{
numbers.Clear();
break;
}
numbers.Add(rotatedNumber);
}
// Add the number and all its rotations
foreach (int number in numbers)
{
circularPrimes.Add(number);
}
}
}
return circularPrimes;
}
public override long Solution()
{
long smallestPrime = 0;
HashSet <int> primes = new HashSet <int>(Primes.EratosthenesSieve(1000000));
foreach (int number in primes)
{
if (number < 10000)
{
continue;
}
string numberString = number.ToString();
foreach (char digit in numberString)
{
List <int> replacedNumbers = new List <int>();
string numberMask = numberString.Replace(digit, '*');
for (char newDigit = '0'; newDigit <= '9'; newDigit++)
{
string replacedNumberString = numberMask.Replace('*', newDigit);
if (replacedNumberString[0] != '0')
{
int replacedNumber = int.Parse(replacedNumberString);
if (primes.Contains(replacedNumber))
{
replacedNumbers.Add(replacedNumber);
}
}
}
if (replacedNumbers.Count == 8)
{
int[] targetPrimes = new int[replacedNumbers.Count];
replacedNumbers.CopyTo(targetPrimes);
Array.Sort(targetPrimes);
Console.WriteLine(replacedNumbers.Count + " - " + string.Join(", ", replacedNumbers));
smallestPrime = targetPrimes[0];
break;
}
}
if (smallestPrime > 0)
{
break;
}
}
return(smallestPrime);
}
public override long Solution()
{
long largestPandigitalPrime = 0;
int[] primes = Primes.EratosthenesSieve(7654321).ToArray();
for (int i = primes.Length - 1; i >= 0; i--)
{
long prime = primes[i];
string primeString = prime.ToString();
if (Numbers.IsPandigital(primeString, primeString.Length))
{
largestPandigitalPrime = prime;
break;
}
}
return(largestPandigitalPrime);
}
public override long Solution()
{
int result = 0;
int longestCount = 0;
List <int> primes = Primes.EratosthenesSieve(1000000);
foreach (int prime in primes)
{
int count = CountOfSumOfPrimes(prime, primes);
if (count > longestCount)
{
longestCount = count;
result = prime;
}
}
return(result);
}
