素数发生器逻辑
我应该创建一个类PrimeNumberGenerator ，它有一个方法nextPrime ，它将打印出所有素数，直到用户输入的数字。
例）
Enter a Number: 20 2 3 5 7 11 13 17 19
我们的老师告诉我们，我们应该使用嵌套for循环。 我试过了，但是当我试图制作内部（嵌套）循环时，我真的很困惑。
这是我的代码:(我稍后会做一个测试课）
public class PrimeGenerator { private int num; boolean isPrime; public PrimeGenerator(int n) { num = n; } public int nextPrime (int num) { for (int i=2; i < num; i++) // The first prime number is 2 and the prime numbers only have to go up to a number the user inputs. { for (int j = 3; j<=i/2; j+=2) // The next prime number is 3 and I attempted to loop through to get the next odd number. { if (num % i == 0) //if the number (upper limit) mod a "prime number" is 0, then that means that number is not really "prime" after all. { break; } } } return num; } }
这里有两个你忘了问的问题：
- 为什么嵌套循环会使一切变得如此复杂？
- 我能做些什么来使事情再次复杂化？
让我们一起玩你实际问的问题，然后回答前两个问题。
您想要做的事情可以这样描述：对于每个数字，1-n，其中n由用户输入，如果它是素数则打印它。
好的，让我们在这里写下伪代码/逻辑。 它看起来像Java，但事实并非如此。 这只是为了传达我们的目标：
int largestNumber = readIntegerFromKeyboard(); for all ints i from 1 to largestNumber { if(isPrime(i)) { println(i); } }
所以，让我们这样做！ 但首先，我们需要一份清单，列出我们需要做的所有事情：
- 从键盘读取整数
- 循环数字
- 检查数字是否为素数
- 打印素数（带换行符）
让我们先做两件容易的事。 读取输入并设置循环：
Scanner keyboard = new Scanner(System.in); int largestNumber = keyboard.nextInt(); for(int i = 1; i <= largestNumber; ++i) { if(isPrime(i)) { System.out.println(i); } } keyboard.close();
好的，这似乎很简单。 到目前为止，这里的一切都有意义。 这很容易理解逻辑。 然而，现在，当我们用实际逻辑替换isPrime时，一切都将变得混乱且难以阅读。
因此，让我们尽可能简单地理解这段代码。 我们将不使用任何技巧来加速代码。 可读性和正确性是我们唯一关心的两件事。 我们将使用模运算符来检查某些东西是否可以均匀分割。 Modulo就像整数除法，除了它返回余数而不是结果。 所以7/2 = 2. 7％2 = 1，因为剩下一个。
Scanner keyboard = new Scanner(System.in); int largestNumber = keyboard.nextInt(); for(int i = 1; i <= largestNumber; ++i) { // checks if the number is a prime or not boolean isPrime = true; for(int check = 2; check < i; ++check) { if(i % check == 0) { isPrime = false; } } if(isPrime) { System.out.println(i); } }
所以好消息是，这是有效的。 坏消息是，这比必要的阅读更难。 而且我们在这里做的不是很多。 当我写这篇文章时，我犯了几个愚蠢的错误，混淆了变量。 也许我很蠢。 所以也许我应该在那种情况下写出愚蠢的代码。 ;）另一方面，你并不愚蠢。 但是你可能和我一起工作，这是愚蠢的，所以你必须自己编写愚蠢的代码，这样你就可以高效地与我合作。
最大的问题是我们在另一个循环的中间有这个庞大的循环。 这就是让我失望的原因。 我提到了错误的循环变量。 但为什么我们需要循环中的循环？ 读起来不是很舒服：
if(isPrime(i)) { System.out.println(i); }
而不是整个混乱？ 你的教授指出了嵌套循环。 但是它让你失望了。 相反，只需编写isPrime方法。 事实是，对于我遇到过的每一个嵌套循环实例都是如此。所以让我们看看它的外观如何：
class Homework { public static void main(String[] args) { Scanner keyboard = new Scanner(System.in); int largestNumber = keyboard.nextInt(); for(int i = 1; i <= largestNumber; ++i) { if(isPrime(i)) { System.out.println(i); } } keyboard.close(); } /** * Checks is a positive integer is a prime number */ public static boolean isPrime(int number) { for(int check = 2; check < number; ++check) { if(number % check == 0) { return false; } } return true; } }
这对我来说更容易阅读。 不是因为逻辑变得容易，而是因为我唯一需要关心的是：
- 检查所有数字并打印正确的数字，或
- 如何检查数字是否为素数。
由于这两个不同的东西现在是分开的，你可以立刻想一想。 高兴，因为你刚刚做了一个适当的抽象。 这使您的代码更容易理解，因为它分离出两个问题。 这是制作大型项目的关键方式。 你采取困难的事情并自己做。 然后你可以自己测试它们，并自己使用它们。
（现在我只需等待回答你没有明确要求的问题的downvotes ......）
根据Eratosthenes的筛子检查此算法的素数。 当然，您需要根据您的计划进行调整。
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 is a prime,then mark multiples of i as non prime for (int j=i; i*j<=N; j++) { isPrime[i*j] = false; } } for (int i=2; i<=N; i++) if (isPrime[i]) //Do something.......
要生成素数，只需循环一个给定的数字并检查该数字是否为素数。 对于有效的素数生成，IsPrime方法必须非常高效和快速。 所以这里是代码来检查给定的数字是否为素数或非常有效。
public static boolean IsPrime(int n) { if (n > 2 && n %2 == 0){ return false; } int top = (int)Math.sqrt(n)+1; for (int i=3;i
这是将生成介于1和给定数字之间的素数的代码。
public class GeneratePrimeNumber { public static void main(String[] args) { System.out.println("Enter number to get prime number"); int n = new Scanner(System.in).nextInt(); for (int j=0;j
我知道这个问题已经有一段时间了，但由于没有人发布java8 / stream方法解决方案，这里有一种可能的方法。
要点可以在这里分叉。
打印输出：[1,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71]
import java.util.*; import java.util.stream.Stream; import static java.util.stream.Collectors.toList; public class PrimeNumber { /** * Java 8 / Lambda approach to generate Prime number. * Prime always start to look from number 1. * @param series Number of how many Prime number should be generated * @return List holding resulting Prime number. */ public static List generate(int series) { Set set = new TreeSet<>(); return Stream.iterate(1, i -> ++i) .filter(i -> i %2 != 0) .filter(i -> { set.add(i); return 0 == set.stream() .filter(p -> p != 1) .filter(p -> !Objects.equals(p, i)) .filter(p -> i % p == 0) .count(); }) .limit(series) .collect(toList()); } // Let's test it! public static void main(String[] args) { List generate = PrimeNumber.generate(20); System.out.println(generate); } }
我认为可以有更快的解决方案….
我们都知道2是第一个素数，素数是一个可以被1和它自身整除的素数。
设N =用户输入的数字，直到我们必须打印素数。 现在，
if(N<2) // No prime numbers if(N==2) // Print 2 if(N>2) //print 2 Create a list(or any resize able data structure) and add 2 to it. now, run a loop from i= 3 to i<=n { count how many numbers in the list are able to divide i completely(Let c denotes it) if(c==0) //print the number as it is prime }
素数的简单定义：一个只能被1和它自身整除的数字。 根据定义，1不是素数。 这是一个powershell算法，用于确定数字是否为素数。
boolean isPrime(int n) { for (int i = 2; i < n; i++) if (n % i == 0) return false; return true; }
尝试使用此代码生成素数系列
public class prime1 {
public static void main(String[] args) { int max = 100; System.out.println("Generate Prime numbers between 1 and " + max); // loop through the numbers one by one for (int i = 1; i < max; i++) { boolean isPrimeNumber = true; // check to see if the number is prime for (int j = 2; j < i; j++) { if (i % j == 0) { isPrimeNumber = false; break; // exit the inner for loop } } // print the number if prime if (isPrimeNumber) { System.out.print(i + " "); } } }
}
公共类PrimeNumberGeneration {
public static void main(String[] args) { // TODO Auto-generated method stub Scanner scan = new Scanner(System.in); int n = scan.nextInt(); ArrayList primeNumbers = new ArrayList (); primeNumbers.add(2); System.out.println(2); no_loop: for(int no=3; no<=n; no+=2){ for(Integer primeNumber: primeNumbers){ if((no%primeNumber)==0){ continue no_loop; } } primeNumbers.add(no); System.out.println(no); } }
}
import java.util.regex.Matcher; import java.util.regex.Pattern; import javax.xml.soap.Node; public class mainone { public static void main(String args[]){ int[] primenumber=new int[13]; for(int a=2,j=0;a<=14;a++,j++){ primenumber[j]=a; } for(int b=1;b<13;b++){ int d=primenumber[b]; if(d%2==0){ primenumber[b]=0; } for(int c=2;c<13;c++){ int e=primenumber[c]; if(e>0){ for(int f=c+1;f<13;f++){ int g=primenumber[f]; if((g>0)&(g%e==0)){ primenumber[f]=0; } } } } } for(int j=0;j<13;j++){ System.out.println(primenumber[j]); } } }
看看我的代码：
import java.util.Scanner; public class c4 { public static void main(String[] args) { Scanner sn = new Scanner(System.in); System.out.println("Enter number"); int num = sn.nextInt(); if (num==1){ System.out.println("Nor Prime Neither Composite"); } for (int i=2;i
这是我的解决方案。
public class PrimeNumberGenerator { public static void print(int n) { // since 1 is not prime number. for (int i = 2; i <= n; i++) { if (isPrime(i)) { System.out.print(i + "\n"); } } } public static boolean isPrime(int num) { for (int i = 2; i * i <= num; i++) { if (num % i == 0) { return false; } } return true; } public static void main(String[] args) { print(10); } }
输出：2 3 5 7
package test; import java.util.Scanner; public static void main(String[] args) { // TODO Auto-generated method stub Scanner reader = new Scanner(System.in); // Reading from System.in System.out.println("Please Enter number you wanted prime number to be generated"); int n = reader.nextInt(); reader.close(); Prime t1 = new Prime(); for (int i = 2; i <= n; i++) { t1.x(i); } } public void x(int n) { // TODO Auto-generated method stub // TODO Auto-generated constructor stub int k = n - 1; int f = 0; if (n == 2) { f = 1; } for (int i = 2; i <= k; i++) { if (n % i == 0) break; else if (k == i) { f = 1; } } if (f == 1) { System.out.println("is prime" + n); } } }