如何在数字的素数因子分解中找到素数的多重性？

Posted 2021-05-03

我必须在所有数字中找到多个最小素数因子，直到10 ^ 7.我正在使用Eratosthenes的Sieve来找到所有素数。并且在一个单独的数组中，我存储了复合数的最小素因子。这是我的代码

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


}

有没有更快的方法来计算这个？

答案

当然，你可以在没有循环的情况下做到这一点。

c最多可能是64位。它不能包含超过63次以外的任何因子。因此，不是循环，而是编写63个嵌套的if语句。

对于j == 2的情况，您的编译器可能具有一些计算尾随零位的内部函数。如果是这种情况，那么你单独处理那个案例，你只需要40个，因为3 ^ 41> 2 ^ 64。

另一答案

如果你想评估n使得jn = c，那么重新解决问题

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

如果n是整数，那么问题就解决了。

当然你需要考虑浮点精度; n可能不是一个完整的整数，但接近于1。

另一答案

一个替代选项，虽然不一定是最有效的，但是编写一个简单的递归函数，例如这个，假设你正在处理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);

但是，请参阅here了解循环与递归的优缺点。

另一答案

既然你要求“最小素数因子的多样性”，你可以很容易地使用相同的筛选方法来获得多样性，就像你习惯于获得最小因子一样。

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

}

如果你想做得更好一点，那么phi[k]==g的步骤和check[k]访问中的一些冗余只需要因为正向序列处理q值。反向使用q会更快。因为q只能在正向序列中轻松计算，并且每个i的q值相当少，所以向后处理q的最简单方法是将q上的循环转换为递归函数（在路上计算q并在递归后处理它）呼叫）。

另一答案

我找到了一个简单的规则，但无法用语言真实地描述。这是计算primenumbers的另一个代码

#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
", 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;
}

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