public ActionResult Problem35(ulong n) { var cal = new PrimeCalculator((uint)n / 3); cal.ExtendToMinimumGT(n); Func <ulong, bool> isCircular = (i) => { ulong c = i; uint numDigits = Utils.NumOfDigits(c); ulong factor = Utils.PowerOfTen(numDigits - 1); do { ulong lower = (c / 10); ulong higher = (c % 10) * factor; // Move rightmost digit to leftmost position c = higher + lower; if (!cal.IsPrimeInRange(c)) { return(false); } }while (c != i); return(true); }; int cnt = cal.Primes.Count(isCircular); return(ViewAnswer(35, "The number of circular primes below " + n + " is", (uint)cnt)); }
public ActionResult Problem10(ulong n) { var cal = new PrimeCalculator((uint)n / 3); cal.ExtendToMinimumGT(n); var sum = cal.Primes.Sum() - cal.LastPrime; return(ViewAnswer(10, "The sum of all primes below " + n + " is", sum)); }
public ActionResult Problem49(uint n) { var cal = new PrimeCalculator(); cal.ExtendToMinimumGT(9999); // We know that the prime numbers will be 4-digit, as stated in problem // Algorithm: // 1) Find all prime numbers between 1000 to 9999, group them by permutations // 2) Skip if number of permutations in group is < n // 3) Find the all arithmetic sequences within group with len >= n // - Not all prime numbers with same permutation will be part of the arithemetic sequence, for example, // for 1487 -> 4817 -> 8147, 1847 won't particpate. // Steps 1 var prime_grps = from p in cal.Primes where p >= 1000 && p <= 9999 group p by p.GetSortedDigits() into g select g; // Step 2 prime_grps = prime_grps.Where(g => g.Count() >= n); // Step 3 var matched_series = prime_grps.SelectMany(g => Utils.FindArithemeticSeries(g, n)); // Stringify solution. Each member of series separates by a comma. Series separates by semicolon var sb = new StringBuilder(); foreach (var series in matched_series) { foreach (var member in series) { sb.Append(member); sb.Append(','); } if (sb.Length > 0) { sb.Remove(sb.Length - 1, 1); // Remove last comma } sb.Append(";"); } if (sb.Length > 0) { sb.Remove(sb.Length - 1, 1); // Remove last semicolon } return(ViewAnswer(49, "4-digit primes which are permutations of each other", sb.ToString())); }
public ActionResult Problem50(ulong n) { var cal = new PrimeCalculator(40000); cal.ExtendToMinimumGT(n); // Cumsums.. cumsum[i] = sum of primes[0 .. i] var primes = cal.Primes; var cumsums = primes.CumSum().ToArray(); // Calc sum from [fromPos, toPos] Func <int, int, ulong> calcSum = (fromPos, toPos) => { int before = fromPos - 1; if (before >= 0) { return(cumsums[toPos] - cumsums[before]); } else { return(cumsums[toPos]); } }; // Find end position for range to examine. int endPos; for (endPos = primes.Length - 1; endPos >= 0 && primes[endPos] > n; endPos--) { ; } // Loop through all possible values for [start, end] to find the longest range whose // sum is still a prime int maxLen = 0, maxStart = 0; ulong maxNum = 0; for (int end = 0; end <= endPos; end++) { for (int start = 0; start < end; start++) { int len = end - start + 1; if (len < maxLen) { continue; } ulong sum = calcSum(start, end); if (sum > n) { continue; } if (!cal.IsPrimeAutoExpand(sum)) { continue; } maxLen = len; maxNum = sum; maxStart = start; } } int maxEnd = maxStart + maxLen - 1; ulong maxValue = calcSum(maxStart, maxEnd); var s = string.Format("{0} + .. + {1} = {2} len = {3}", primes[maxStart], primes[maxEnd], maxValue, maxEnd, maxLen); return(ViewAnswer(50, s, maxValue)); }