所以,我是一个办法懒洋洋地生成素数的工作,我想出了这三个定义,这在同等方式,所有的工作 - 只是检查每个新的整数是否具有上述所有质数中的一个因素:
primes1 :: [Integer]
primes1 = mkPrimes id [2..]
where mkPrimes f (x:xs) =
if f (const True) x
then
let g h y = y `mod` x > 0 && h y in
x : mkPrimes (f . g) xs
else
mkPrimes f xs
primes2 :: [Integer]
primes2 = mkPrimes id (const True) [2..]
where mkPrimes f f_ (x:xs) =
if f_ x
then
let g h y = y `mod` x > 0 && h y …在找到第10,001个素数时,我的内存耗尽.
object Euler0007 {
def from(n: Int): Stream[Int] = n #:: from(n + 1)
def sieve(s: Stream[Int]): Stream[Int] = s.head #:: sieve(s.filter(_ % s.head != 0))
def primes = sieve(from(2))
def main(args: Array[String]): Unit = {
println(primes(10001))
}
}
这是因为在每次"迭代"(这是这个上下文中的正确术语吗？)之后primes,我增加要调用的函数堆栈以使下一个元素一个接一个？
我在网上找到的一个解决方案是不使用迭代解决方案(我想避免进入函数式编程/惯用scala),这就是问题7(问题7):
lazy val ps: Stream[Int] = 2 #:: Stream.from(3).filter(i => ps.takeWhile(j => j * j <= i).forall(i % _ > 0))
从我所看到的,这不会导致这种类似递归的方式.这是一个很好的方法吗,或者你知道更好的方法吗？
performance primes scala out-of-memory sieve-of-eratosthenes
我正在编码站点上解决以下问题。对于测试（隐藏测试）中的某些边缘情况，它失败了，但我不确定它们是什么。有人看到这有什么问题吗？
问题：假设A是一串所有素数按顺序压缩在一起（即235711131719...）。给定一个索引n，返回一个由 5 位数字组成的字符串，其中第一个数字n位于 A中的索引处。
例如foo(0) => 23571和foo(10) => 19232
这是我的代码：
def gen_primes():
A = {}
i = 2
while True:
if i not in A:
yield i
A[i * i] = [i]
else:
for p in A[i]:
A.setdefault(p + i, []).append(p)
del A[i]
i += 1
def answer(n):
counter = 0
prime_string = ""
for p in gen_primes():
if (counter >= n):
prime_string += str(p)
counter += len(str(p)) …我一直在使用埃拉托色尼的筛经历素数生成Python和人们吹捧为一个相对较快的选项,例如那些在少数人的解决方案 的答案的一个问题关于Python优化素数代都没有直接的和我在这里简单的实现与效率相媲美.我的实现如下
def sieve_for_primes_to(n):
size = n//2
sieve = [1]*size
limit = int(n**0.5)
for i in range(1,limit):
if sieve[i]:
val = 2*i+1
tmp = ((size-1) - i)//val
sieve[i+val::val] = [0]*tmp
return sieve
print [2] + [i*2+1 for i, v in enumerate(sieve_for_primes_to(10000000)) if v and i>0]
定时执行返回
python -m timeit -n10 -s "import euler" "euler.sieve_for_primes_to(1000000)"
10 loops, best of 3: 19.5 msec per loop
虽然下面给出了上述链接问题的答案中描述的方法,该方法是python菜谱中最快的
import itertools
def erat2( ):
D = { }
yield 2
for q in itertools.islice(itertools.count(3), …我正在从这里修改Eratosthenes的无限筛子,所以它使用轮子分解来跳过更多的复合材料而不是当前检查所有可能性的形式.
我已经弄清楚如何生成步骤以达到车轮上的所有间隙.从那里我想我可以用+ 2代替这些轮子步骤,但它导致筛子跳过素数.这是代码:
from itertools import count, cycle
def dvprm(end):
"finds primes by trial division. returns a list"
primes=[2]
for i in range(3, end+1, 2):
if all(map(lambda x:i%x, primes)):
primes.append(i)
return primes
def prod(seq, factor=1):
"sequence -> product"
for i in seq:factor*=i
return factor
def wheelGaps(primes):
"""returns list of steps to each wheel gap
that start from the last value in primes"""
strtPt= primes.pop(-1)#where the wheel starts
whlCirm= prod(primes)# wheel's circumference
#spokes are every number that are divisible …python primes infinite sieve-of-eratosthenes wheel-factorization
我目前正在尝试为 Kattis 问题实现埃拉托斯特尼筛的一个版本，但是，我遇到了一些内存限制，我的实现无法通过。
这是问题陈述的链接。简而言之，这个问题要求我首先返回小于或等于n 的素数数量，然后求解一定数量的查询，判断数字i是否为素数。内存使用量限制为 50 MB，并且只能使用 python 标准库（无 numpy 等）。内存限制是我陷入困境的地方。
到目前为止，这是我的代码：
import sys
def sieve_of_eratosthenes(xs, n):
count = len(xs) + 1
p = 3 # start at three
index = 0
while p*p < n:
for i in range(index + p, len(xs), p):
if xs[i]:
xs[i] = 0
count -= 1
temp_index = index
for i in range(index + 1, len(xs)):
if xs[i]:
p = xs[i]
temp_index += 1
break
temp_index += 1 …我想在我的python素数查找器中获得无限范围!这是我的代码!
import math
print "Welcome to Prime Finder!"
option = raw_input("continue(y/n)")
if option == "y":
for num in range(1,(infinite number)):
if all(num%i!=0 for i in range(2,int(math.sqrt(num))+1)):
print num
我试图得到它所说的(无限数)实际上是一个无限数.有什么价值或东西我可以用来找到它吗？任何帮助将不胜感激!
我正在写一个递归无限素数生成器,我几乎可以肯定我可以更好地优化它.
现在,除了前十几个素数的查找表之外,每次调用递归函数都会收到所有先前素数的列表.
因为它是一个懒惰的生成器,所以现在我只是过滤掉任何以前的素数为0的任何数字,并取出第一个未经过滤的结果.(检查我正在使用短路,因此,当前一个素数首次将当前数字均分时,它会中止该信息.)
现在,我在搜索第400个素数(37,813)时性能下降.我正在寻找方法来使用我有一个所有先前质数列表的独特事实,并且我只搜索下一个,以改进我的过滤算法.(我能找到的大多数信息提供非懒筛找到下一个素数的限制,或方法来查找与p ñ个素数给定P N-1 ,不优化,求P ñ给出2.P N-1的素数. )
例如,我知道在p Ñ个素数必须驻留在范围(P N-1 + 1)...(P n-1个 + P N-2 ).现在我开始在p n-1 + 2 处对整数进行滤波(因为p n-1 + 1只能是p n-1 = 2的素数,这是预先计算的).但由于这是一个懒惰的生成器,知道范围的终端边界(p n-1 + p n-2)并没有帮助我过滤任何东西.
鉴于所有以前的素数,我能做些什么来更有效地过滤？
@doc """
Creates an infinite stream of prime numbers.
iex> Enum.take(primes, 5)
[2, 3, 5, 7, 11]
iex> Enum.take_while(primes, fn(n) -> n < 25 end)
[2, 3, 5, 7, 11, 13, 17, 19, 23]
"""
@spec primes :: Stream.t …algorithm primes generator lazy-evaluation sieve-of-eratosthenes
我正在尝试编写一个生成函数来打印素数,如下所示
def getPrimes(n):
prime=True
i=2
while(i<n):
for a in range(2,i):
if(i%a==0):
prime=False
break
if(prime):
yield i
然而,我没有得到理想的结果p = getPrimes(100)应该给我一个生成器函数,它将从2到100迭代质数,但我得到的结果是[2,3].我究竟做错了什么？
我对如何解决这个问题有点困惑。我需要所有素数才能返回 true。如果不返回 false——我看到我的逻辑包括 2 并且返回 0，所以它自动返回 false，因为 2 余数为 0。
function isPrime(num, div = 2) {
// BASE CASE:
if(num <= div ) return false; // IF num less than OR equal to 2 RETURN false
// IF num MOD has a remainder of zero
if(num % 2 === 0) return false // RETURN false
return true; // RETURN true
// RECURSIVE CALL:
return isPrime(num)
}
console.log(isPrime(1)); //-> false
console.log(isPrime(2)); //-> true
console.log(isPrime(3)); //-> true
console.log(isPrime(4)); //-> false