Java 我需要一个更好的素数检查算法
素数真的很奇怪。。。出于厌倦，我创建了这个简单的模式。我在网上没有看到任何相似之处。正如您所看到的，根据您选择的比例，图片中有空白线，范围从值1到1000000 我打算从价值1-25000000，也许1-1000000000 也许使用筛子技术会有所帮助，但我需要一个适当的java实现，我使用经典的prime checker，它由2个for循环组成，这确实会浪费时间 编辑：这是我的代码示例Java 我需要一个更好的素数检查算法,java,algorithm,optimization,solution,Java,Algorithm,Optimization,Solution,素数真的很奇怪。。。出于厌倦，我创建了这个简单的模式。我在网上没有看到任何相似之处。正如您所看到的，根据您选择的比例，图片中有空白线，范围从值1到1000000 我打算从价值1-25000000，也许1-1000000000 也许使用筛子技术会有所帮助，但我需要一个适当的java实现，我使用经典的prime checker，它由2个for循环组成，这确实会浪费时间 编辑：这是我的代码示例 boolean checkPrime(long a) { long count = 0L; f
boolean checkPrime(long a)
{
long count = 0L;
for(long op = 1;op<=a;op++)
if(a%op==0)
count++;
return count ==2;
}
布尔校验素数（长a）
{
长计数=0L；
对于（long op=1；op），您展示的代码正在为每个a进行a操作。
这是一个简单的改进方法：
boolean checkPrime(long a)
{
long count = 0L;
for(long op = 2;op*op<=a;op++)
if(a%op==0)
return false;
return true;
}
布尔校验素数（长a）
{
长计数=0L；
对于（long op=2；op*op如果你想找到每一个素数，那么你可以使用一个版本的erathmus筛来生成前1000个左右的素数，然后只检查先前素数的列表，因为它们是代数基本定理中唯一有意义的因子。如果你想找到所有素数，这几乎肯定比使用一般的nu更快mber字段筛，设计用于在没有素数列表的情况下，有效地计算大数。下面是我为Euler项目7编写的一篇文章。它有两个函数，一个是使用erathmus的筛来查找1000以下的所有素数，然后使用素数列表作为输入，依次计算下一个数which通过初步列表的试验划分为初步
public class NthPrime {
/**
* @param args
*/
public static void main(String[] args)
{
int N = 10001;
long startTime = System.currentTimeMillis();
ArrayList<BigInteger> firstPrimes = primes(1000);
System.out.println("The "+N +"th Prime is: " + Nthprime(firstPrimes, N));
long stopTime = System.currentTimeMillis();
long elapsedTime = stopTime - startTime;
System.out.println(firstPrimes.toString());
System.out.println(elapsedTime);
}
public static BigInteger Nthprime(ArrayList<BigInteger> primes, int N)
{
if(N < primes.size())
{
return primes.get(N-1);
}
BigInteger start = primes.get(primes.size()-1);
boolean bool = true;
BigInteger ZERO = new BigInteger("0");
BigInteger ONE = new BigInteger("1");
BigInteger j = new BigInteger("1");
while(bool)
{
boolean hasfactor = false;
for(int i=0; i<primes.size(); i++)
{
BigInteger Q = start.add(j);
BigInteger remainder = Q.mod(primes.get(i));
if(remainder.equals(ZERO))
{
hasfactor = true;
break;
}
}
if(!hasfactor)
{
primes.add(start.add(j));
}
if(primes.size() == N)
{
bool = false;
}
j = j.add(ONE);
}
return primes.get(primes.size()-1);
}
public static ArrayList<BigInteger> primes(int N)
{
boolean[] primes = new boolean[N+1];
for(int j = 0; j<N+1; j++)
{
primes[j] = true;
}
int i = 2;
while(i < N+1)
{
if(primes[i])
{
int j = 2*i;
while(j<N+1)
{
primes[j] = false;
j = j+i;
}
}
i++;
}
ArrayList<BigInteger> allprimes = new ArrayList<BigInteger>();
for(i=2; i<N+1; i++)
{
if(primes[i])
{
allprimes.add(new BigInteger((new Integer(i)).toString()));
}
}
return allprimes;
}
公共类{
/**
*@param args
*/
公共静态void main（字符串[]args）
{
int N=10001；
long startTime=System.currentTimeMillis（）；
ArrayList firstPrimes=素数（1000）；
System.out.println（“第+N+个素数是：”+N个素数（第一个素数，N））；
长停止时间=System.currentTimeMillis（）；
长延时=停止时间-开始时间；
System.out.println（firstPrimes.toString（））；
System.out.println（elapsedTime）；
}
公共静态BigInteger素数（ArrayList素数，int N）
{
if（N对数N
系数）@RichardKenneethniescio你提到你未能实现维基百科中的一些算法。你为什么不选择其中一个，并就你在维基百科中遇到的困难提出一个具体的问题。另外，按照Niklas的建议，使用Erasthotenes筛选。在某处查找。该算法相当容易理解。Niklas的评论是关于算法计算复杂度的数学分析（与执行所需的时间有关）。此外，请尝试更清楚地了解您将来实际要求的内容=）原始测试对于数十亿个数字来说还是太慢了，不管你使用哪种算法。一个筛子就是去向上的方法：你也可以考虑只看一个素数项目上的素数……而且，ErthMUS的筛子更快，所以在样本代码中，你可以增加素数的值。它会使所有素数小于1000000。在我的机器上不到100毫秒。它受到int的最大大小的限制，因为它取决于数组，所以不会超过2^32-1。这对你来说可能不是问题。它的复杂性是n*log（log（n）），所以比线性的差，但不是我的多。筛选10亿以下的所有素数需要10秒。使用long[]
作为位图并省略偶数，您可以升级到2.7e11，这可能需要几次演出，也可能需要几个小时。
boolean checkPrime(long a)
{
long count = 0L;
for(long op = 2;op*op<=a;op++)
if(a%op==0)
return false;
return true;
}
#include<iostream>
#include<cmath>
#include<cstdlib>
using namespace std;
const int losowania=20;
long long pote(long long x,long long k,long long m)//this function is counting (x^k)mod m
{
if(k==1)
{
return x%m;
}
if(k%2==0)
{
long long a=pote(x,k/2,m);
return ((__int128_t)((__int128_t)a*(__int128_t)a)%(__int128_t)m);
}
else
{
long long a=pote(x,k-1,m);
return ((__int128_t)((__int128_t)a*(__int128_t)x)%(__int128_t)m);
}
}
bool Rabin_Miler(long long p,long long x)
{
if(pote(x,p-1,p)!=1)
{
return false;
}
long long wyk=(p-1);
while(wyk%2==0)
{
wyk/=2;
}
long long teraz=pote(x,wyk,p);
if(teraz==1)
{
return true;
}
while(teraz!=1&&teraz!=p-1)
{
teraz=(__int128_t)((__int128_t) teraz*(__int128_t)teraz)%(__int128_t)p;
}
if(teraz==1)
{
return false;
}
else
{
return true;
}
}
bool is_prime(long long p)
{
srand(100);
for(int i=0;i<losowania;i++)
{
if(!Rabin_Miler(p,(rand()%(p-1))+1))
{
return false;
break;
}
}
return true;
}
public class NthPrime {
/**
* @param args
*/
public static void main(String[] args)
{
int N = 10001;
long startTime = System.currentTimeMillis();
ArrayList<BigInteger> firstPrimes = primes(1000);
System.out.println("The "+N +"th Prime is: " + Nthprime(firstPrimes, N));
long stopTime = System.currentTimeMillis();
long elapsedTime = stopTime - startTime;
System.out.println(firstPrimes.toString());
System.out.println(elapsedTime);
}
public static BigInteger Nthprime(ArrayList<BigInteger> primes, int N)
{
if(N < primes.size())
{
return primes.get(N-1);
}
BigInteger start = primes.get(primes.size()-1);
boolean bool = true;
BigInteger ZERO = new BigInteger("0");
BigInteger ONE = new BigInteger("1");
BigInteger j = new BigInteger("1");
while(bool)
{
boolean hasfactor = false;
for(int i=0; i<primes.size(); i++)
{
BigInteger Q = start.add(j);
BigInteger remainder = Q.mod(primes.get(i));
if(remainder.equals(ZERO))
{
hasfactor = true;
break;
}
}
if(!hasfactor)
{
primes.add(start.add(j));
}
if(primes.size() == N)
{
bool = false;
}
j = j.add(ONE);
}
return primes.get(primes.size()-1);
}
public static ArrayList<BigInteger> primes(int N)
{
boolean[] primes = new boolean[N+1];
for(int j = 0; j<N+1; j++)
{
primes[j] = true;
}
int i = 2;
while(i < N+1)
{
if(primes[i])
{
int j = 2*i;
while(j<N+1)
{
primes[j] = false;
j = j+i;
}
}
i++;
}
ArrayList<BigInteger> allprimes = new ArrayList<BigInteger>();
for(i=2; i<N+1; i++)
{
if(primes[i])
{
allprimes.add(new BigInteger((new Integer(i)).toString()));
}
}
return allprimes;
}