判断1-1000以内的素数

如果您想判断1-1000以内的素数，可以使用筛法来实现。具体的做法是：

1. 从2开始，找到第一个没有被标记为合数的数，记为p；
2. 将p的倍数标记为合数；
3. 重复步骤1和2，直到p^2 > n为止，此时剩下的数即为素数。

代码如下：

def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

primes = []
for i in range(2, 1001):
    if is_prime(i):
        primes.append(i)
print(primes)

相关问题

用Java写一个判断1-100以内的质数

### 回答1：

public class PrimeNumber {
    public static void main(String[] args) {
        for (int i = 2; i <= 100; i++) {
            boolean isPrime = true;
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime) {
                System.out.print(i + " ");
            }
        }
    }
}

上面的代码使用了两重循环，外层循环遍历1-100的整数，内层循环判断这个整数是否为质数。如果一个整数在2到它自身的平方根之间没有整除因子，那么它就是质数。

### 回答2：
要用Java写一个判断1-100以内质数的程序，可以采用以下的方法：

1. 创建一个名为PrimeNumber的类。
2. 在PrimeNumber类中创建一个名为isPrime的静态方法，该方法接受一个整数参数n，并返回一个布尔值作为判断结果，判断n是否为质数。
3. 在isPrime方法中，首先判断如果n小于2，则直接返回false，因为小于2的数都不是质数。
4. 然后使用一个循环从2开始到n的平方根范围内依次除以每个数，判断n是否能被该数整除，如果能整除则返回false。
5. 如果循环结束后仍然没有找到n的因数，则返回true，表示n是质数。
6. 在主函数中，创建一个循环从1到100，调用isPrime方法判断每个数是否为质数，并输出结果。

以下是完整的Java代码：

public class PrimeNumber {
    public static boolean isPrime(int n) {
        if (n < 2) {
            return false;
        }
        
        for (int i = 2; i <= Math.sqrt(n); i++) {
            if (n % i == 0) {
                return false;
            }
        }
        
        return true;
    }
    
    public static void main(String[] args) {
        for (int i = 1; i <= 100; i++) {
            if (isPrime(i)) {
                System.out.println(i + "是质数");
            }
        }
    }
}

运行以上代码，程序会输出1-100中的所有质数。

### 回答3：
要用Java写一个判断1-100以内的质数的程序，可以使用一个循环来遍历1到100之间的每个数，并通过判断该数是否能被除了1和本身以外的数整除来确定是否为质数。

以下是用Java语言编写的判断1-100以内的质数的程序：

public class PrimeNumbers {
    public static void main(String[] args) {
        for (int i = 2; i <= 100; i++) {
            boolean isPrime = true;
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime) {
                System.out.print(i + " ");
            }
        }
    }
}

解析：程序中的第一个循环用于遍历1到100之间的每个数。第二个循环用于检查当前数是否能被除了1和本身以外的数整除。如果能被整除，我们将该数标记为非质数并退出当前循环。如果最终没有找到能整除的数，那么该数就是质数。

运行该程序，会输出1-100之间的所有质数。输出结果为：

2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

循环结构训练任务 设计java程序，输入一个数，判断是否是质数。（较高要求：打印1-1000以内所有质数）

循环结构在编程中用于重复执行某段代码，直到满足特定条件。在Java中，常见的循环结构有for循环、while循环和do-while循环。为了设计一个判断输入数是否为质数的程序，我们通常会用到for循环。下面是相应的Java程序示例：

import java.util.Scanner;

public class PrimeNumberChecker {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个数：");
        int number = scanner.nextInt();
        if (isPrime(number)) {
            System.out.println(number + " 是质数。");
        } else {
            System.out.println(number + " 不是质数。");
        }
        
        // 打印1-1000以内所有质数
        System.out.println("1-1000以内的质数有：");
        for (int i = 1; i <= 1000; i++) {
            if (isPrime(i)) {
                System.out.print(i + " ");
            }
        }
    }
    
    public static boolean isPrime(int number) {
        if (number <= 1) {
            return false;
        }
        for (int i = 2; i <= Math.sqrt(number); i++) {
            if (number % i == 0) {
                return false;
            }
        }
        return true;
    }
}

这段代码首先导入了`Scanner`类，用于获取用户的输入。`main`方法中，程序提示用户输入一个数，并通过`isPrime`方法判断该数是否为质数。`isPrime`方法内部使用了一个for循环来检查该数是否有除了1和它自身以外的因数。如果在循环中找到了这样的因数，则该数不是质数。最后，程序还会打印出1到1000以内的所有质数。