我试图编写一个使用谓词方法的程序，该方法可以找到1-100之间的所有素数。我知道有更有效的方法可以找到素数，但现在我想使用蛮力策略并尝试所有可能的组合。
现在程序就是这样，只打印10,000次真假，但我希望我的程序只打印数字，如果它们是素数。所以在程序完成后，我会得到一个介于1- 100之间的素数列表。
1.我的程序是否正确我想要做的事情？ 2.什么是好的建议改变我的程序，以便它列出1-100之间的所有素数。
import acm.program.*;
public class PrimeNumbers extends ConsoleProgram{
public void run(){
for (int i =1; i <= 100, i++){
for (int j =1; j<= 100; j++){
println(yesPrime(i, j));
}
}
}
private boolean yesPrime (int n, int k){
return ( n % k == 0)
}
}
}
答案 0 :(得分：10)
你没有检查素数。您正在测试从1到100的两个数字的所有10,000个组合，以查看第二个是否均匀地划分第一个。
但它可能正确地做到了。
您想要做的伪代码：
for each number n from 2:100
for each divisor d from 2:n-1
test to see if d divided n evenly
end for
if no values of d other than n divided n evenly
print "n is prime"
end for
为您提供一些优化方案：
玩得开心！
答案 1 :(得分：3)
使用Eratosthenes的筛子：
public static void main(String[] args) {
int n = 100; // the max number for test
// Sieve of Eratosthenes
boolean[] sieve = new boolean[n + 1];
for (int i = 2; i <= n; i++) {
sieve[i] = true;
}
for (int i = 2; i <= n; i++) {
if (sieve[i] != false) {
for (int j = i; j * i <= n; j++) {
sieve[i * j] = false;
}
}
}
// Print prime numbers
for (int i = 0; i <= n; i++) {
if (sieve[i]) {
System.out.println(i);
}
}
}
答案 2 :(得分：1)
嗯，您要从yesPrime返回比较结果，然后在run中打印该比较结果。猜猜输出是什么。
认为这是一项任务，我想给你一个提示，而不是答案。
检查yesPrime的结果。如果为true，则打印数字并退出循环。
答案 3 :(得分：1)
Scanner reader = new Scanner(System.in);
System.out.println("Enter the a number");
int num = reader.nextInt();
int counter = 0;
int root = 0;
boolean prime_flag;
if (2 <= num) {
// 2 is the only even prime number
counter++;
}
for (int i = 3; i < (num + 1); i++) {
// test only for odd number
if (i % 2 != 0) {
prime_flag = true;
root = (int) (Math.sqrt(i) + 1);
for (int j = 3; j < (root + 1); j++) {
if ((i % j == 0) && (i != j)) {
prime_flag = false;
break;
}
}
if (prime_flag) {
counter++;
}
}
}
System.out.println("Count of prime numbers upto " + num + " is "
+ counter);
答案 4 :(得分：0)
我会创建一个函数，就像你的yesPrime函数一样。这只需要一个数字，并检查该数字是否为素数。
像
这样的东西boolean yesPrime(int n)
{
// check to see if n is divisble by numbers between 2 and sqrt(n)
// if the number is divisible, it is not prime, so return false
// after the loop has checked all numbers up to sqrt(n), n must be prime so return true
}
然后在主程序中，循环显示数字1到100并为每个数字调用yesPrime。如果结果为true，则打印该编号。
我的遗憾是编程的一个目标是将问题分解为更小的子问题。通过编写一个函数来测试素数，你可以避免在一个函数中使用嵌套循环，这可能更难理解。
答案 5 :(得分：0)
首先，您需要检查从2开始的素数。并且您不会检查所有100个数字，只是每个数字作为从2到（数字-1）的因子。每个数字都可被整除1和它本身。
public static void main(String[] args) {
boolean b;
for (int i = 2; i < 100; i++) {
b = checkPrime(i);
if (b)
System.out.println(i);
}
}
private static boolean checkPrime(int k) {
for (int i = 2; i < k; i++) {
//check if the number is divisible by any number starting from 2 till number -1.If it is, it is not a prime number
if (k % i == 0)
return false;
}
// return true if the number is not divisible by any number from 2 to number -1 i.e. it s a prime number.
return true;
}
答案 6 :(得分：0)
想想这个逻辑
所有可被2整除的数字都不是素数，因此您可以将数字增加2
如果一个数字不能被素数整除，那么它就是素数
试试这段代码
public static void main(String[] args) throws IOException
{
int[] prime=new int[50]; //array to store prime numbers| within 1 to ==> prime numbers will be <=n/2 here n=100
int i=1; //index for "num" array
int j=1; //index for storing to "prime" array
int k=1; //index for browsing through prime array
prime[0]=2; // setting the first element
int flag=1; // to check if a number is divisibe for than 2 times
for(i=3;i<=100;i+=2) {
for(k=0;prime[k]!=0;k++) //browsing through the array to till non zero number is encountered
{
if(i%prime[k]==0) flag++; //checking if the number is divisible, if so the flag is incremented
}
if(flag<2)
{
prime[j++]=i; // if the flag is still 1 then the number is a prime number
}
flag=1;
}
System.out.println(Arrays.toString(prime)); //a short way to print an array
}
答案 7 :(得分：0)
在给定范围内轻松查找素数 / * 请实现此方法以返回给定范围内的所有素数列表（包括）。素数是一个自然数，它具有两个不同的自然数除数，即1和素数本身。第一个素数是：2,3,5,7,11,13 * /
public void getPrimeNumbers(int st, int en){
// int st=1, en=100;
for(int i=st;i<=en;i++)
if( (i%2!=0) && (i%1==0 && i%i==0) )
System.out.println("Yes prime");
}
答案 8 :(得分：0)
public static void main(String[] args) {
boolean isPrime = true; //set isPrime to true
for (int i = 2; i<100;i++){ // consider i is increasing number
for (int j=2; j<i; j++) //j is divisor & must be less than
//i and increasing after each iteration
{
if((i % j)== 0){ // if i gets divisible by
// any increasing value of j from 2
//then enters in this case and makes value
//nonPrime
isPrime=false; //changes value
break; //breaks "for loop of j"
}
} //ends "for loop of j"
if(isPrime) // if case wont work then number is prime
{
System.out.println(i + " is Prime");
}
isPrime = true; //sets isPrime to default true.
}
}
答案 9 :(得分：0)
使用不太复杂的方法，我们可以这样做：
import java.math.BigInteger;
public class PrimeNumbers {
public static void main(String[] args) {
BigInteger min = new BigInteger("2");
BigInteger max = new BigInteger("100");
while(min.compareTo(max) < 0){
System.out.println(min);
min = min.nextProbablePrime();
}
}
}
答案 10 :(得分：0)
这是我找到素数的解决方案。
public class PrimeNumberFinder {
public boolean isPrime(int number) {
return number > 1 && IntStream.rangeClosed(2, number / 2)
.noneMatch(value -> number % value == 0);
}
}