我正在尝试使用此方法生成素数列表.我需要遍历每个数字2 ... n并检查它是2 ... n的倍数.出于某种原因,错误的列表似乎正在被修改.
import sys
import argparse
import math
parser = argparse.ArgumentParser(description='find the largest prime factor of a number')
parser.add_argument('n', type=int, help='number')
args = parser.parse_args()
sieve = []
for i in range(2,args.n+1): sieve.append(i) # tried int(i)
copy1 = sieve # tried making extra copies. . .
copy2 = sieve
copy3 = sieve
#print int(math.sqrt(args.n))
for index, i in enumerate(copy1):
#print index, i
for ii in copy2:
#print ii
if i % ii == 0:
sieve[index]= None …我对Haskell(以及一般的函数式编程)很新,我正在尝试一些基本的练习来试图理解语言.我正在编写一个"天真"的素数检查器,它将每个数字除以输入以检查是否有任何余数.到目前为止我学到的唯一构造是理解列表和递归函数,所以我受此限制.这是我正在尝试的:
isprime 1 = False
isprime 2 = True
isprime n = isprimerec n (n-1)
isprimerec _ 1 = False
isprimerec n t = if (n `rem` t) == 0 then False else isprimerec n (n-1)
意图是用户会使用isprime n.然后isprime将用于isprimerec确定该数字是否为素数.这是一个非常圆润的方式,但我对Haskell的知识有限,我不知道其他任何方式.
这是我尝试这样做时会发生的事情:
isprimerec 10 9
永远运行.我必须使用Ctrl + C来阻止它.
isprimerec 10 5
返回False.该else部件永远不会被评估,因此该函数从不调用自身.
我不确定为什么会这样.此外,这是否接近Haskell程序员如何处理这个问题？(我并不是说检查素性,我知道这不是这样做的方式.我只是这样做是为了练习).
我正在编写一个代码,在一个名为primes.txt的文件中写入2到1000之间的所有素数.出于某种原因,我无法找出解决此问题的正确方法.
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
public class Problem6 {
/**
* @param args
* @throws FileNotFoundException
*/
public static void main(String[] args) throws FileNotFoundException {
PrintWriter prw = new PrintWriter("primes.txt");
for (int i = 2; i <= 1000; i++){
if (checkIfPrime(i) == true){
System.out.println(i);
prw.println(i);
}
}
}
public static boolean checkIfPrime (int num){
boolean isPrime = true;
for (int i = 2; i <= 1000; i++){
if ( num % i == 0 ){
isPrime = false; …这里x,y <= 10 ^ 12且yx <= 10 ^ 6
我从左到右循环并检查每个数字是否为素数.当x和y有点像10 ^ 11和10 ^ 12时,这种方法非常慢.更快的方法？我将所有素数存储到10 ^ 6 ..我可以用它们来找到10 ^ 10-10 ^ 12之类的巨大值之间的素数？
for(i=x;i<=y;i++)
{
num=i;
if(check(num))
{
res++;
}
}
我的检查功能
int check(long long int num)
{
long long int i;
if(num<=1)
return 0;
if(num==2)
return 1;
if(num%2==0)
return 0;
long long int sRoot = sqrt(num*1.0);
for(i=3; i<=sRoot; i+=2)
{
if(num%i==0)
return 0;
}
return 1;
}
我正在尝试编写一个接受整数x的函数,如果是prime则返回True,否则返回False.它的工作正常,除了测试数字121时我无法弄清楚原因.这是我的代码:
def is_prime(x):
if x < 2:
return False
elif x == 2:
return True
else:
for i in range(2,x):
if x%i == 0:
return False
else:
return True
当检查121时,它似乎跳过if x%i == 0:,因为121%11是0,但它不会返回为False.我错过了一些明显的东西吗？我很感激能得到的任何帮助,谢谢.哦,我正在使用Python 2.7
纯粹是为了好玩,我决定写一个简单的算法,找到2和x之间的所有素数,其中x是你想要的.我用a clock_t来计算算法完成变化x值需要多长时间.(我去x = 0,然后是25000,然后是50000,然后是75000,......,最多1,000,000).例如,当x = 25000时,我进入for循环,i从2到25000,并且对于每个值i,我通过将它除以两个和它自身之间的每个数字来检查它是否是素数,寻找剩余的0.
这是算法:
vector<int> calcPrimesWithoutPrechecking(int upperLimit)
{
vector<int> res;
for(int i = 2; i <= upperLimit; i++)
{
int currentNum = i;
bool foundDivisible = false;
for(int j = 2; j < currentNum; j++)
{
if(currentNum % j == 0)
{
foundDivisible = true;
break;
}
}
if(!foundDivisible)
{
res.push_back(i);
}
}
return res;
}
我想我可以通过检查我们当前正在测试的数字的最后一位数来加快速度.如果该数字是0,2,4,5,6或8,那么我甚至不必检查它是否是素数,因为我知道它不是(当然2,3和5都是,所以那些被处理在一开始的时候).我打电话给这个预先检查.这是预先检查的算法:
vector<int> calcPrimesWithPrechecking(int upperLimit)
{
vector<int> res;
res.push_back(2);res.push_back(3);res.push_back(5);
for(int i = 6; i <= …我写了一个初学者程序,旨在查找和打印任何数字的素数因子:
def is_prime(n):
if n == 3:
return True
elif n == 4:
return False
else:
n = int(n**0.5)+1
for i in range(2,n):
if n % i == 0:
return False
return True
def prime_factors(n):
for i in range(2,n):
if n % i == 0:
x = i
primes.append(x)
y = n / x
return y
break
primes = []
def main(y):
while not is_prime(y):
y = prime_factors(y)
primes.append(y)
print(primes)
以下是该程序的运行示例,让我感到困惑:
main(625)
[5, 5, 5, 5]
...
main(160)
[160]
... …我一直试图解决这个问题:https://codility.com/programmers/task/common_prime_divisors/
我有它在返回正确答案方面的功能,但对于更大的数字来说它非常慢,我想看看是否有人更好地采取更快的做法或解释我可以优化它的方式.
bool IsPrime(int number)
{
for (int i = 2; i < number; i++)
{
if (number % i == 0)
{
return false;
}
}
return true;
}
bool GetPrimeFactors(int valueA, int valueB)
{
if(valueA < 0 || valueB < 0)
return false;
int max = sqrt(std::max(valueA, valueB)) + 1;//sqrt(std::max(valueA, valueB));
std::vector<int> factors;
bool oneSuccess = false;
for(int i = 2; i <= max; i++)
{
bool remainderA = valueA % i == 0;
bool …我想写一个程序,它从素数列表中删除包含偶数位的所有素数.
任何人都可以解释为什么这个代码返回正确的结果如果limit = 200,但如果limit = 300则返回错误？
def odd_primes(limit):
r = list(gen_primes(limit))
for i in r[:]:
for j in str(i):
if int(j)%2==0:
r.remove(i)
return r
哪个gen_primes(limit)是在限制下返回所有素数的发电机.
如果limit = 200则返回:
[3, 5, 7, 11, 13, 17, 19, 31, 37, 53, 59, 71, 73, 79, 97, 113, 131, 137, 139, 151, 157, 173, 179, 191, 193, 197, 199]
但如果限制为300,我会收到此错误:
line 19, in odd_primes
r.remove(i)
ValueError: list.remove(x): x not in list
为什么会这样？我该如何纠正呢？
我正在用scala查看素数.我使用以下代码来检查数字n是否为素数.
(2 until n) forall(d=>n%d!=0)
我检查了scala对素数的返回速度有多快179426549.
(2 until 179426549L.toInt) forall(d=>179426549L%d!=0)
res22: Boolean = true
然后我尝试了一个更大的数字32416190071来看看为这个更大的素数返回真实需要多长时间.
(2 until 32416190071L.toInt) forall(d=>32416190071L%d!=0)
res23: Boolean = true
令我惊讶的是,返回值为true会更快地返回更大的素数.为什么更大的数字更快地返回真实？