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

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

也許這有助於理解，最好的問候