Question

所以我正在尝试制作一个素数查找器，为了节省计算时间，我希望它在找到一个非1的除数或数字本身时中止forloop。现在该功能有效，但它完全忽略了我的if语句。我做错了什么？

def prime(number):
    oldnum = number
    factor = 1
    while number > 1:
        factor += 1
        while number % factor == 0:
            if 1< factor < oldnum:
                return 0 # is not prime
                print("yay")
                break
            number //= factor
    return 1 #prime!

Answer 1

只需使用Erathostenes's sieve即可。这是一种古老且经过验证的方法来寻找素数：）

Answer 2

您的代码永远不会到达return 1行（顺便说一句，应该是return True），因为

您的break语句只会突破内部while循环
之前未发现break声明，因为您之前return 0。

无论如何，你的内部while循环应该是if（因为你实际上并没有做任何需要循环的事情）。

如果你改变了（并删除了无法访问的代码），它“有效”（除了prime(1) True的错误结果），这是找到素数的一种非常低效的方法。

def prime(number):
    oldnum = number
    factor = 1
    while number > 1:
        factor += 1
        if number % factor == 0:
            if 1 < factor < oldnum:
                return False # is not prime
            number //= factor
    return True # is prime!

Answer 3

只是对性能改进做一点评论，您只需要检查因素from 2 to sqrt(num)，而不是2 to num。

Answer 4

这个功能怎么样？

import math

def prime(number):
  if number == 1:
    return 1
  for i in range(2, int(math.sqrt(number)) + 1):
    if number % i == 0:
      return 0
  return 1

Answer 5

由于你的最终目标是有效地找到素数，而其他人已经很好地回答了编码问题，我将比其他答案更详细地介绍如何更有效地进行编码。

Sieve of Eratosthenes是查找素数的最快方式，最多可达1000万左右。但是你似乎想确定是否只有一些给定的数字n是否为素数。

要检查数字n是否为素数，您只需检查它是否可被 primes 整除，小于或等于至{{1 }}。所以使用这种方法，如果你希望你的函数能够处理高达1亿的数字，你只需要准备一份高达10000（1229个素数）的所有素数的列表，这将花费的时间可以忽略不计。

如果你有兴趣我可以在这里进行筛选实施，但我猜你是为了自己的娱乐而解决这个问题，所以我会告诉你。

Answer 6

蒂姆指出，你需要内在的同时成为一个if。像这样的东西会起作用（但效率非常低）

def prime(number):
    oldnum = sqrt(number)
    factor = 1
    while factor <= oldnum:
        factor += 1
        if number % factor == 0 :
            return 0 # is not prime
    return 1 #prime!

Answer 7

我同意以上答案.. 如果数字x只有因子1并且本身...... 理想的方法是检查从2到天花板功能是否有任何因素（sqrt（x））... 其中上限函数（n）是指大于或等于n的最小整数。

C中的函数看起来像......

//函数返回.. { - ＆GT; -1既不是素数也不是复合物.. - ＆GT; 0表示复合数字.. - ＆GT; 1为素数.. }

.....................................

 boolean isPrime(int n){

     if(n<=1){
       return -1;
     }else{
      for(int i=2;i<Math.sqrt(n);i++){
        if(n%i==0)
         return 1;
      }
      return 0;
     }
    }

Answer 8

试试这个（Sieve of Eratosthenes的实现）。

def squares_till(n):
    def square_add(i,n):
        j = i**2
        while j < n:
            yield j
            j = j + i
    A = [True]*n
    A[0] = A[1] = False
    for i in range(2,int(n**0.5)):
        if A[i]:
            for j in square_add(i,n):
                A[j] = False
    return [num for num in range(n) if A[num]]

Answer 9

我不知道你的担忧，但我认为它运作良好

def is_prime(number):
if number > 2:
    i = 2
    while number > i:
        if number % i == 0:
            return False
            break
        else:
            i=i+1
    return True

elif number == 2:
    return True
else:
    return False

Answer 10

我相信，这是非常有效的实施。可以通过结合原始性测试（O（1）实施）进一步改进。

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
#include <string>

using namespace std;

void printN(const vector<int> container, int count, ostream& out=cout, const string& delim=", ") {
    for(int i=0; i<count; ++i)
        out << container[i] << delim;
    out << endl;
}

void printNPrimes(int count) {
    static const int FIRST_PRIME = 2;
    static vector<int> primes(1, FIRST_PRIME);
    static int rangeEnd = 3;

    if(primes.size() >= count) {
        printN(primes, count);
        return;
    }

    int remainingPrimeNumbers = count - primes.size();

    while(remainingPrimeNumbers) {
        bool is_prime = true;
        for(int prime : primes) {
            if(rangeEnd % prime == 0) {
                is_prime = false;
                break;
            }
        }

        if(is_prime) {
            primes.push_back(rangeEnd);
            --remainingPrimeNumbers;
        }

        ++rangeEnd;
    }

    printN(primes, count);
}

int main(int argc, const char *argv[])
{
    if(argc < 2) {
        cout << "usage: rund <count>";
        return -1;
    }

    int count = atoi(argv[1]);
    printNPrimes(count);
    return 0;
}

素数查找器

10 个答案: