public static long Solution()
{
var exactlyOneSolution = 0;
var primes = UtilityFunctions.Primes(limit);
var index = 0;
var prime = primes[++index];
foreach (int p in primes)
{
if (p % 4 == 3)
{
exactlyOneSolution += 1;
}
if (16 * p < limit)
{
exactlyOneSolution += 2;
}
else if (4 * p < limit)
{
exactlyOneSolution += 1;
}
}
return(exactlyOneSolution);
}
static void TimeStuff()
{
var stopwatch = new Stopwatch();
while (true)
{
var limit = 100000000;
stopwatch.Start();
var primes3 = UtilityFunctions.Primes(limit);
stopwatch.Stop();
Console.WriteLine($"Primes3 took {stopwatch.ElapsedMilliseconds} milliseconds to run.");
stopwatch.Reset();
stopwatch.Start();
var primes2 = UtilityFunctions.Primes(limit);
stopwatch.Stop();
Console.WriteLine($"Primes2 took {stopwatch.ElapsedMilliseconds} milliseconds to run.");
stopwatch.Reset();
stopwatch.Start();
var primes1 = UtilityFunctions.Primes(limit);
stopwatch.Stop();
Console.WriteLine($"Primes1 took {stopwatch.ElapsedMilliseconds} milliseconds to run.");
stopwatch.Reset();
Console.ReadLine();
}
}
public static double Solution()
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var subsetCount = (long)Math.Pow(2, ProblemDigits.Count);
PrimeCandidates = new List <long> [subsetCount];
for (int i = 0; i < subsetCount; i++)
{
PrimeCandidates[i] = new List <long>();
}
var primes = UtilityFunctions.Primes(98765432);
foreach (var p in primes)
{
var digitSignature = UtilityFunctions.DigitSignature(p, ProblemDigits);
if (digitSignature > 0)
{
PrimeCandidates[digitSignature].Add(p);
}
}
return(PandigitalPrimeSets(ProblemDigits));
}
public static long Solution()
{
long solution = 0;
var primes = UtilityFunctions.Primes(8000);
var residues = new List <long> {
1, 3, 7, 9, 13, 27
};
for (long num = 10; num < limit; num += 10)
{
if (num % 3 == 0 || (num % 7 != 3 && num % 7 != 4) || num % 13 == 0)
{
continue;
}
bool skipNum = false;
for (int i = 3; i < primes.Count; i++)
{
long p = primes[i];
if (p > num * num)
{
break;
}
var r = num % p;
foreach (var s in residues)
{
if ((r * r + s) % p == 0)
{
skipNum = true;
break;
}
}
if (skipNum)
{
break;
}
}
if (skipNum)
{
continue;
}
var nSquared = num * num;
if (UtilityFunctions.IsPrime(nSquared + 1) &&
UtilityFunctions.IsPrime(nSquared + 3) &&
UtilityFunctions.IsPrime(nSquared + 7) &&
UtilityFunctions.IsPrime(nSquared + 9) &&
UtilityFunctions.IsPrime(nSquared + 13) &&
UtilityFunctions.IsPrime(nSquared + 27) &&
!UtilityFunctions.IsPrime(nSquared + 19) &&
!UtilityFunctions.IsPrime(nSquared + 21))
{
solution += num;
Console.WriteLine(num);
}
}
return(solution);
}
public static long Solution()
{
var stopwatch = new Stopwatch();
long solution = 0;
var primes = UtilityFunctions.Primes(limit);
var minima = new long[limit + 1];
minima[0] = 1;
foreach (var p in primes)
{
long primePower = p;
long exponent = 1;
while (primePower <= limit)
{
long upper = exponent;
long lower = 1;
while (upper - lower > 1)
{
long mid = (upper + lower) / 2;
if (UtilityFunctions.LargestPowerDividingFactorial(p * mid, p) < exponent)
{
lower = mid;
}
else
{
upper = mid;
}
}
minima[primePower] = (upper) * p;
stopwatch.Start();
for (long i = 1; i <= limit / primePower; i++)
{
minima[i * primePower] = Math.Max(minima[i], minima[primePower]);
}
stopwatch.Stop();
primePower *= p;
exponent += 1;
}
}
Console.WriteLine($"Populating table took {stopwatch.ElapsedMilliseconds}.");
for (long i = 1; i < limit; i++)
{
solution += minima[i + 1];
}
return(solution);
}
public static long Solution()
{
long solution = 3;
var primes = new HashSet <long>(UtilityFunctions.Primes(limit));
var eligibleN = new HashSet <long>();
foreach (var p in primes)
{
if (2 * p - 4 > limit)
{
break;
}
if (primes.Contains(2 * p - 3))
{
if (p % 6 == 1)
{
eligibleN.Add(2 * p - 4);
}
else if (primes.Contains((p + 16) / 3) && primes.Contains((2 * p + 5) / 3))
{
eligibleN.Add(2 * p - 4);
}
}
}
foreach (var n in eligibleN)
{
bool allPrime = true;
for (var j = 5; j < Math.Sqrt(n); j++)
{
if (n % j == 0)
{
var p = j + n / j;
if (!primes.Contains(p))
{
allPrime = false;
break;
}
}
}
if (allPrime)
{
solution += n;
}
}
return(solution);
}
public static long Solution()
{
long solution = 0;
var primes = UtilityFunctions.Primes(limit);
foreach (var p in primes.Where(t => t > 4))
{
UtilityFunctions.Gcd(-24, p, out long inverse, out var dummy);
var residue = ((inverse + p) * 9) % p;
solution += (residue % p);
}
return(solution);
}
public static long Solution()
{
var stopwatch = new Stopwatch();
long solution = 1;
var exponents = new List <int>();
var primes = UtilityFunctions.Primes(7376512);
var candidates = new List <long> {
1
};
for (int i = 0; i < primes.Count; i++)
{
var primePower = primes[i] * primes[i];
var maxCandidate = candidates.Max();
if (primePower > primes.Last() && primePower > maxCandidate)
{
break;
}
while (primePower < Math.Max(primes.Last(), maxCandidate))
{
candidates.Add(primePower);
if (maxCandidate > primes.Last())
{
candidates.Remove(maxCandidate);
maxCandidate = candidates.Max();
}
else
{
primes.RemoveAt(primes.Count - 1);
}
primePower *= primePower;
}
}
foreach (var t in candidates.Concat(primes))
{
solution = (solution * t) % 500500507;
}
Console.WriteLine($"Time spent finding max {stopwatch.ElapsedMilliseconds}");
return(solution);
}
public static long Solution()
{
long solution = 0;
var primes = UtilityFunctions.Primes(limit / 2);
for (int i = 0; i < primes.Count; i++)
{
var p = primes[i];
List <long> powersOfP = new List <long>();
var n = p;
while (n < limit / p)
{
powersOfP.Add(n);
n *= p;
}
for (int j = i + 1; j < primes.Count; j++)
{
var q = primes[j];
if (p * q > limit)
{
break;
}
var powersOfPTimesQ = new List <long>(powersOfP);
long max = 0;
while (true)
{
powersOfPTimesQ = powersOfPTimesQ.Where(t => t * q <= limit).Select(t => t * q).ToList();
if (powersOfPTimesQ.Count == 0)
{
break;
}
max = Math.Max(powersOfPTimesQ.Max(), max);
}
solution += max;
}
}
return(solution);
}
public static long Solution()
{
long solution = 0;
var primes = UtilityFunctions.Primes(limit + 100);
for (int i = 3; true; i++)
{
var p1 = primes[i - 1];
var p2 = primes[i];
if (p1 > limit)
{
break;
}
long powerOf10 = (long)Math.Pow(10, p1.ToString().Length);
var x = (-p1 * UtilityFunctions.ModularInverse(powerOf10, p2) % p2 + p2) % p2;
solution += powerOf10 * x + p1;
}
return(solution);
}
public static long Solution()
{
var stopwatch = new System.Diagnostics.Stopwatch();
long solution = 0;
var divisorsOfOrder = UtilityFunctions.Divisors(order);
var primes = UtilityFunctions.Primes((int)Math.Sqrt(UtilityFunctions.IntegralPower(2, order / 2) + 1));
var primeFactors = UtilityFunctions.PrimeFactors(UtilityFunctions.IntegralPower(2, order) - 1, primes);
var reducedPrimes = primeFactors.Select(t => t.Item1).ToList();
foreach (var d in divisorsOfOrder)
{
var m = UtilityFunctions.Moebius(d, null, primes);
if (m != 0)
{
var divisorsOfPowerOfTwo = UtilityFunctions.Divisors(UtilityFunctions.IntegralPower(2, order / d) - 1, null, reducedPrimes);
solution += (divisorsOfPowerOfTwo.Sum() + divisorsOfPowerOfTwo.Count()) * m;
}
}
return(solution);
}
public static long Solution()
{
long solution = 0;
var primes = UtilityFunctions.Primes(limit);
foreach (var p in primes)
{
var ord = UtilityFunctions.MultiplicativeOrder(10, 9 * p);
if (ord == 0)
{
solution += p;
continue;
}
while (ord % 2 == 0 || ord % 5 == 0)
{
if (ord % 2 == 0)
{
ord /= 2;
}
if (ord % 5 == 0)
{
ord /= 5;
}
}
if (ord > 1)
{
solution += p;
}
else
{
Console.WriteLine(p);
}
}
return(solution);
}
public static long Solution()
{
long solution = 0;
var counter = 0;
var stopwatch = new Stopwatch();
stopwatch.Start();
var previousTime = 0.0;
var currentTime = 0.0;
var primes = UtilityFunctions.Primes(1000000);
currentTime = stopwatch.ElapsedMilliseconds;
Console.WriteLine($"Settig up took {currentTime - previousTime} milliseconds.");
previousTime = currentTime;
foreach (var p in primes)
{
var order = UtilityFunctions.MultiplicativeOrder(10, 9 * p);
if (order == 0)
{
continue;
}
if (limit % order == 0)
{
solution += p;
counter += 1;
Console.WriteLine(p);
if (counter >= 40)
{
return(solution);
}
}
}
return(solution);
}
public static long Solution1()
{
long solution = 0;
long power = UtilityFunctions.IntegralPower(2, order) - 1;
var primes = UtilityFunctions.Primes(UtilityFunctions.IntegralPower(2, order / 4));
var primeFactors = new List <long>();
var ordersModP = new List <long>();
var powersOfTwo = new Dictionary <long, long>();
bool keyAdded = false;
var factors = new Dictionary <long, long>();
for (int i = 2; i <= Math.Sqrt(order); i++)
{
if (order % i == 0)
{
powersOfTwo.Add(i, UtilityFunctions.IntegralPower(2, i) - 1);
if (i * i != order)
{
powersOfTwo.Add(order / i, UtilityFunctions.IntegralPower(2, order / i) - 1);
}
}
}
var keys = powersOfTwo.Keys.OrderBy(t => t).ToArray();
foreach (var p in primes)
{
if (power < p * p)
{
keyAdded = false;
primeFactors.Add(power);
foreach (var key in keys)
{
if (powersOfTwo[key] % power == 0)
{
keyAdded = true;
ordersModP.Add(key);
break;
}
}
if (!keyAdded)
{
ordersModP.Add(order);
}
break;
}
var primePower = p;
while (power % p == 0)
{
keyAdded = false;
primeFactors.Add(p);
foreach (var key in keys)
{
if (powersOfTwo[key] % primePower == 0)
{
keyAdded = true;
ordersModP.Add(key);
break;
}
}
if (!keyAdded)
{
ordersModP.Add(order);
}
power /= p;
primePower *= p;
}
}
factors.Add(1, 1);
for (int i = 0; i < primeFactors.Count; i++)
{
keys = factors.Keys.ToArray();
foreach (var key in keys)
{
var newKey = key * primeFactors[i];
if (!factors.ContainsKey(newKey))
{
factors.Add(newKey, UtilityFunctions.Lcm(factors[key], ordersModP[i]));
}
}
}
foreach (var factor in factors)
{
if (factor.Value == order)
{
solution += factor.Key + 1;
}
}
return(solution);
}
