Algorithms/JavaAlgorithms
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add description for Sieve of Eratosthenes algorithm (Fixes: #2724) (#2725)

Browse Source
This commit is contained in:
Artem Boiarshinov 2021-10-27 22:01:53 +03:00 committed by GitHub
parent 1899d2a439
commit b2de5c7f1e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 53 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
Others/SieveOfEratosthenes.java
View File

@ -1,44 +1,76 @@
package Others; package Others;
/** @author Varun Upadhyay (https://github.com/varunu28) */ import java.util.Arrays;
/**
* Sieve of Eratosthenes is an ancient algorithm for finding all prime numbers up to any given limit.
* It does so by iteratively marking as composite (i.e., not prime) the multiples of each prime,
* starting with the first prime number, 2.
* The multiples of a given prime are generated as a sequence of numbers starting from that prime,
* with constant difference between them that is equal to that prime.
* This is the sieve's key distinction from using trial division to sequentially test each
* candidate number for divisibility by each prime.
* Once all the multiples of each discovered prime have been marked as composites, the remaining
* unmarked numbers are primes.
* <p>
* Poetry about Sieve of Eratosthenes:
* <p><i>Sift the Two's and Sift the Three's:</i></p>
* <p><i>The Sieve of Eratosthenes.</i></p>
* <p><i>When the multiples sublime,</i></p>
* <p><i>The numbers that remain are Prime.</i></p>
*
* @see <a href="https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes">Wiki</a>
*/
public class SieveOfEratosthenes { public class SieveOfEratosthenes {
/** /**
* This method implements the Sieve of Eratosthenes Algorithm * @param n The number till which we have to check for prime Prints all the prime numbers till n.
* * Should be more than 1.
* @param n The number till which we have to check for prime Prints all the prime numbers till n * @return array of all prime numbers between 0 to n
*/ */
public static void findPrimesTillN(int n) { public static int[] findPrimesTill(int n) {
int[] arr = new int[n + 1]; // Create array where index is number and value is flag - is that number a prime or not.
// size of array is n + 1 cause in Java array indexes starts with 0
Type[] numbers = new Type[n + 1];
for (int i = 0; i <= n; i++) { // Start with assumption that all numbers except 0 and 1 are primes.
arr[i] = 1; Arrays.fill(numbers, Type.PRIME);
} numbers[0] = numbers[1] = Type.NOT_PRIME;
arr[0] = arr[1] = 0; double cap = Math.sqrt(n);
// Main algorithm: mark all numbers which are multiples of some other values as not prime
for (int i = 2; i <= Math.sqrt(n); i++) { for (int i = 2; i <= cap; i++) {
if (arr[i] == 1) { if (numbers[i] == Type.PRIME) {
for (int j = 2; i * j <= n; j++) { for (int j = 2; i * j <= n; j++) {
arr[i * j] = 0; numbers[i * j] = Type.NOT_PRIME;
} }
} }
} }
//Write all primes to result array
int primesCount = (int) Arrays.stream(numbers)
.filter(element -> element == Type.PRIME)
.count();
int[] primes = new int[primesCount];
int primeIndex = 0;
for (int i = 0; i < n + 1; i++) { for (int i = 0; i < n + 1; i++) {
if (arr[i] == 1) { if(numbers[i] == Type.PRIME) {
System.out.print(i + " "); primes[primeIndex++] = i;
} }
} }
System.out.println(); return primes;
}
private enum Type {
PRIME, NOT_PRIME
} }
// Driver Program
public static void main(String[] args) { public static void main(String[] args) {
int n = 100; int n = 100;
System.out.println("Searching for all primes from zero to " + n);
// Prints 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 int[] primes = findPrimesTill(n);
findPrimesTillN(n); System.out.println("Found: " + Arrays.toString(primes));
} }
} }