相关疑难解决方法(0)

我正在努力学习Python编程,我对此很陌生.

我在打印一系列素数从一到百时遇到了问题.我无法弄清楚我的代码是什么问题.

这是我写的; 它打印所有奇数而不是素数:

for num in range(1,101):
    for i in range(2,num):
        if (num%i==0):
            break
        else:
            print(num)
            break

来自Project Euler的问题10 是找到给定n下面所有素数的总和.

我只是通过总结Eratosthenes筛子产生的素数来解决它.然后我通过Lucy_Hedgehog(次线性!)找到了更有效的解决方案.

对于n =2⋅10^ 9:

• Python代码(来自上面的引用)在Python 2.7.3中运行1.2秒.

• C++代码(我的)在大约0.3秒内运行(用g ++ 4.8.4编译).

我在Haskell中重新实现了相同的算法,因为我正在学习它:

import Data.List

import Data.Map (Map, (!))
import qualified Data.Map as Map

problem10 :: Integer -> Integer
problem10 n = (sieve (Map.fromList [(i, i * (i + 1) `div` 2 - 1) | i <- vs]) 2 r vs) ! n
              where vs = [n `div` i | i <- [1..r]] ++ reverse [1..n …

我环顾四周,找到了其他有问题的答案,但没有一个问题涉及这个问题的范围.包括这个问题,还有这个问题.

我必须以有效的方式计算大范围数字的LCM.我对其他问题看起来并不太深入,因为它们没有处理与此算法必须处理的数字范围一样大的数字范围.

我现在得到的代码可以在大约90秒内计算1到350000之间的每个数字的最小值.(结果数字是大约76000十进制数字).我希望最终能够在数百万甚至数十亿元素的范围内扩展它.

它最终可能会被瘫痪.对于某些算法,这根本不会很难,对于其他算法,它会更棘手(例如,如果算法使用当前生成的LCM来计算其计算的其他部分的素数)

这里是:

public static BigInteger getLCMOfRange(BigInteger lower, BigInteger upper)
{
    BigInteger M = BigInteger.ONE;
    BigInteger t;

    // long l = System.currentTimeMillis();
    // System.out.println("Calculating LCM of numbers up to " + upper + "...");
    for (; lower.compareTo(upper) != 1; lower = lower.add(BigInteger.ONE))
    {
        t = M.gcd(lower);
        if (t.compareTo(lower) == 0)
            continue;
        M = M.multiply(lower).divide(t);
    }
    // System.out.println("Done.  Took " + (System.currentTimeMillis() - l) + " milliseconds.  LCM is " + M.bitCount()+ " bits …

目前我有这个素数发生器,限制在n <2 ^ 32-1.鉴于数组中元素的限制,我不完全确定如何进一步扩展限制.

筛:

public class Main {

public static void main(String args[]){
    long N = 2000000000;

    // initially assume all integers are prime

    boolean[] isPrime = new boolean[N + 1];
    for (int i = 2; i <= N; i++) {
        isPrime[i] = true;
    }

    // mark non-primes <= N using Sieve of Eratosthenes
    for (int i = 2; i*i <= N; i++) {

        // if i is prime, then mark multiples of i as nonprime
        // suffices to …

我尝试使用Sieve Eratosthenes方法列出最多20亿的素数.这是我用的!

我面临的问题是,我无法超过1000万个数字.当我尝试时,它说"分段错误".我在互联网上搜索找到原因.有些网站说,这是编译器本身的内存分配限制.有人说,这是硬件限制.我使用的是安装了4GB RAM的64位处理器.请建议我列出它们的方法.

#include <stdio.h>
#include <stdlib.h>

#define MAX 1000000
long int mark[MAX] = {0};

int isone(){
   long int i;
   long int cnt = 0;
   for(i = 0; i < MAX ; i++){
      if(mark[i] == 1)
         cnt++;
   }
   if(cnt == MAX)
      return 1;
   else
      return 0;
}



int main(int argc,char* argv[]){
   long int list[MAX];
   long int s = 2;
   long int i;
   for(i = 0 ; i < MAX ; i++){
      list[i] = s;
      s++;
   }
   s = 2; …

就像这个问题一样,我也在研究Eratosthenes的筛子.同样来自"编程原理和使用c ++的实践"一书,第4章.我能够正确地实现它,它的功能正如练习所要求的那样.

#include <iostream>
#include <vector>

using namespace std;

int main() {
    unsigned int amount = 0;

    cin >> amount;

    vector<int>numbers;

    for (unsigned int i = 0; i <= amount; i++) {
        numbers.push_back(i);
    }

    for (unsigned int p = 2; p < amount; p++) {
        if (numbers[p] == 0)
            continue;

        cout << p << '\n';

        for (unsigned int i = p + p; i <= amount; i += p) {
            numbers[i] = false;
        }
    }

    return …

我最近阅读了有关大量数字的更快的Eratosthenes分段筛网实施方案的信息。

以下是相同的实现：

function sieve(low, high) {

    var primeArray = [], ll = Math.sqrt(low), output = [];

    for (var i = 0; i < high; i++) {
        primeArray[i] = true;
    }

    for (var i = 2; i <= ll; i++) {
        if (primeArray[i]) {
            for (var j = i * i; j < high; j += i) {
                primeArray[j] = false;
            }
        }
    }

    for (var i = 2; i < ll; i++) {
        if(primeArray[i])
        {
            var segmentStart = Math.floor(low/i) * …

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