您如何在数的素数分解中找到素数的多重性？

Question

我必须找到所有素数最小的素数直到10 ^ 7的多重性。我正在使用Eratosthenes筛子来查找所有素数。 在一个单独的数组phi中，我存储了最小的复合数素数。这是我的代码

 for(ull i=2;i<=m;i++)
{
    if (check[i])
    {
         uncheck[i]=true;
        for (ull k=i*i; k<=n; k+=i)
         {
           if(check[k]==true)
           phi[k]=g;
           check[k]=false;
         }  
    }

}

现在我正在运行一个循环，直到n并在其中使用循环来计算它。 这是该代码

 for(ull i=4;i<=n;i++)
{

    if(check[i]==false)
    {   
        ull count=0; 
        ull l=i;
         ull r=phi[i];
         while(l%r==0)
         {
            l=l/r;
            count++;
         }               
        cout<<count<<'\n';
    }


}

有没有更快的方法来计算呢？

Answer 1

绝对可以，您无需循环即可执行此操作。

c最多为64位。 除1之外的其他任何因素都不能超过63次。 因此，您编写了63个嵌套的if语句，而不是循环。

对于j == 2的情况，您的编译器可能具有一些内在函数，它们会计算结尾的零位。 如果真是这样，那么您将单独处理该情况，并且仅需要40个if，因为3 ^ 41> 2 ^ 64。

Answer 2

如果要评估n使得j ⁿ = c，则将问题重铸为

n = log（c）/ log（j）。

如果n是整数，那么您的问题已解决。

当然，您需要在此处考虑浮点精度； n可能不是精确的整数，但接近一个整数。

Answer 3

尽管不一定是最有效的，但另一种选择是编写一个简单的递归函数，例如这样，假设您正在处理int：

int recurseSubtract(int c, int j, int count){
  if ((c==j)) {
    return count + 1;
  } else {
     c = c-j;
     subtract(c, j, count++);
  }
}

int count = recurseSubtract(c,j,0);

但是，请参见此处 ，了解循环与递归的优缺点。

Answer 4

由于您要求“ 最小质数的倍数”，因此您可以轻松地使用与获得最小因数相同的筛分方法来获得多重性。

 for(ull i=2;i<=m;i++)
{
    if (check[i])
    {
        uncheck[i]=true;  // WHY??
        ull k=i*i;
        for (ull q=i; q<maxq; k=(q*=i))
        for ( ; k<=n; k+=q)
         {
           if(check[k]==true)
               phi[k]=g;  // I copied 'g' from you, but didn't you mean 'i'?
           if ( phi[k]==g )
               count[k]++;
           check[k]=false;
         }  
    }

}

如果您想做得更好，则仅因为q值按正向顺序处理，才需要phi[k]==g的步骤以及check[k]访问中的一些冗余。 反向使用q会更快。 由于q只能按正向顺序轻松计算，并且每个i几乎不存在q，因此向后处理q的最简单方法是将q上的循环转换为递归函数（在递归的过程中计算q并在递归后对其进行处理呼叫）。

Answer 5

我发现了一个简单的规则，但无法用语言描述。 这是另一个计算素数的代码

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
double f_power(double val, int exp);
int main(int argc,char* argv[]) {

    int p[2];
    int ctr = 0;
    int ctr2 = 0;
    int it_m = 0;
    int it_1 = 0;
    int it_2 = 0;
    int it_c = 0;


    int index = 3;
    srand(time(NULL));
    double t = clock();
    double s = clock();
    int prime = 2;
    FILE *file;
    file = fopen("ly_prime.txt", "w");
    //f_power(2.0, 57885161)
    for (it_m = 2; it_m <= 2000; it_m++) {
        for (it_1 = it_m, ctr2 = 0, it_c = it_m; it_1 >= 2; it_1--) {
            for (it_2 = it_1; it_2 >= 2; it_2--) {
                if (it_1 * it_2 - it_c == 0) {
                p[ctr % 2] = it_c;
                if (ctr >= 1 && p[ctr % 2] - p[(ctr - 1) % 2] == 2) {
                    //prime[0] = (p[ctr % 2] - 1);
                    prime = (p[ctr % 2] - 1);
                    fprintf(stdout, "|%d _ i: %d _ %d\n", isPrime(prime),index, prime);
                    index++; 
                }
                ctr++;
                }
            }
        }
    }
    t = clock() - t;
    fprintf(file, "|%d_ %d_ %d ", prime, index - 2, ctr);

}
double f_power(double val, int exp) {
int i = 0;
double help = val;
for(i = 1; i < exp; i++) {
    val *= help;
}
return val;
}
int isPrime(int number)
{
        int i = 2;
    for(i=2; i < number; i++)
    {
            int leftOver=(number % i);

            if (leftOver==0)
            {
                    return 1;
                    break;
            }

    }
            return 0;
}

也许这有助于理解，最好的问候