范围高达 10^15 的质数

Question

如何优化算法的速度/效率？

我需要计算 1 到 10^15 范围内的素数总数。
编辑：约束：last-first<=10^9
下面的代码适用于较小的范围（从 1 到 2000000）并且需要 4 秒（几乎）。

static void Main(string[] args)
    {
        string[] s = Console.ReadLine().Split(' ');
        DateTime start = DateTime.Now;
        var first = Convert.ToInt64(s[0]);
        var last = Convert.ToInt64(s[1]);
        int counter = 0;
        for (long i = first; i <= last; i++)
        {
            if (i > 2 && i%2==0)
            {
                continue;
            }
            if (isPrime(i))
            {
                counter++;
            }
        }
        Console.WriteLine(counter);
        TimeSpan duration = DateTime.Now - start;
        Console.WriteLine(duration.TotalMilliseconds);
        Console.ReadLine();
    }
    public static bool isPrime(long number)
    {
        if (number == 1) return false;
        if (number == 2) return true;

        for (int i = 2; i <= Math.Ceiling(Math.Sqrt(number)); ++i)
        {
            if (number % i == 0) return false;
        }
        return true;
    }

正如您在for loop 中看到的，首先我检查数字是否为i > 2 && i%2==0，因为在这种情况下，数字不是素数。

还有什么技巧可以避免这些数字无法到达isPrime 方法，或者避免超时的最佳解决方案是什么？注意：此代码有效，但问题是我需要避免超时，即 4 秒。

Answer 1

为了让您的 isPrime 逻辑领先一步，您可以使用以下内容：

public static class Primes
{
  private static readonly HashSet<int> FirstPrimes 
    = new HashSet<int> 
      { 
        2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 
        67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 
        139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 
        211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 
        281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 
        367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 
        443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 
        523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 
        613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 
        691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 
        787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 
        877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 
        971, 977, 983, 991, 997 
      };
  private const int StartNum = 1009;
  public static bool IsPrime(Int64 num)
  {
    // Check if number is in Prime Array
    if (num < Int32.MaxValue && FirstPrimes.Contains((Int32)num))
    {
      return true;
    }
    // Check divisibility w/Prime Array
    if (FirstPrimes.Any(prime => num % prime == 0))
    {
      return false;
    }
    // Main iteration for Primality check
    var upMargin = (Int64)Math.Sqrt(num) + 1;
    var j = StartNum;
    while (j <= upMargin)
    {
      if (num % j == 0)
      {
        return false;
      }
      j += 2;
    }
    return true;
  }
}

您可以用更多的素数填充FirstPrimes，并将StartNum 设置为不在FirstPrimes 中的下一个素数。理论上应该越快。

更多素数参见例如：https://primes.utm.edu/lists/

Answer 2

我解决这个问题的方法是，我在SlicerMain 函数中将最大数量切片为 5 个切片。 SlicerMain 函数进一步获取每个切片的上下界，并将其发送给 PrimeCounter 函数，该函数返回切片边缘之间的素数总数。

static void Main(string[] args)
    {
       DateTime start = DateTime.Now;

       var max = 2000000;// Math.Pow(10, 15);
       int slices = 5;
       SlicerMain(slices, max);

       Console.WriteLine(counter);
       TimeSpan duration = DateTime.Now - start;
       Console.WriteLine(duration.TotalMilliseconds);

       Console.ReadLine();
   }

/// <summary>
/// It slices the big number into smaller ones
/// </summary>
/// <param name="slices">Total Number of slices</param>
/// <param name="max">Big number</param>
public static void SlicerMain(int slices, double max)
    {
       Parallel.For(0, slices,
                    index =>
                         {
                             double up = max * (index + 1) / slices;
                             double low = max * (index) / slices + 1;
                             Interlocked.Add(ref counter, PrimCounter(low, up));
                         });
    }

/// <summary>
/// Optimized Prime Counter
/// </summary>
/// <param name="first">slice lower bound</param>
/// <param name="last">slice uper bound</param>
/// <returns>Count of prime numbers</returns>
public static int PrimCounter(double first, double last)
        {
            int localCounter = 0;
            for (double a = first; a < last; a++)
            {
                bool prime = true;
                for (int c = 2; c * c <= a; c++)
                {
                    if (a % c == 0)
                    {
                        prime = false;
                        break;
                    }
                }
                if (prime)
                    localCounter++;
            }
            return localCounter;
        }

此slicing 用于并行处理和利用机器的最大资源。提高片数将减少计算素数的总时间，但您可以将其提高到 PC 的核心或它可以承受的并行度。 我希望这能解决您的问题。