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