Find primes using Sieve of Eratosthenes

#include <stdio.h>
#include <stdlib.h>
/* Part of Cosmos by OpenGenus Foundation */
int sieve_of_eratosthenes(int **primes, const int max) {
	// Allocate memory
	int *isPrime = (int *)malloc(sizeof(int) * (max + 1));
	int i;
	// Assume all numbers to be prime initially
	for(i = 0; i <= max; ++i)
		isPrime[i] = 1;
	// 0 and 1 are not prime
	isPrime[0] = 0;
	isPrime[1] = 0;
	// Maintain a count of primes as we encounter them
	int count = 0;
	// We need a count of all primes as we move
	// This means we cannot iterate to root(max)
	for(i = 2; i <= max; ++i)
	{
		if(isPrime[i] == 1)
		{
			++count;
			int j;
			// Set all multiples of i as not prime
			for(j = 2 * i; j <= max; j += i)
				isPrime[j] = 0;
		}
	}
	*primes = (int *)malloc(sizeof(int) * count);
	int j = 0;
	for(i = 0; i <= max; ++i)
	{
		if(isPrime[i] == 1)
		{
			(*primes)[j++] = i;
		}
	}
	return count;
}
int main() {
	int n = 100, i;
	int *primes = NULL;
	// Find primes up to n
	int size = sieve_of_eratosthenes(&primes, n);
	printf("Primes up to %d are:\n", n);
	for(i = 0; i < size; ++i)
	{
		printf("%d\n", primes[i]);
	}
	return 0;
}
   

#include <iostream>
#include <vector>
using namespace std;
// Part of Cosmos by OpenGenus Foundation
void SieveOfEratosthenes(int n)
{
    // Create a boolean array "prime[0..n]" and initialize
    // all entries it as true. A value in prime[i] will
    // finally be false if i is Not a prime, else true.
    vector<bool> prime(n + 1, true);
    for (int p = 2; p * p <= n; p++)
        // If prime[p] is not changed, then it is a prime
        if (prime[p] == true)
            // Update all multiples of p
            for (int i = p * 2; i <= n; i += p)
                prime[i] = false;
    // Print all prime numbers
    for (int p = 2; p <= n; p++)
        if (prime[p])
            cout << p << " ";
}
// Driver Program to test above function
int main()
{
    int n;
    cout << "Enter the number";
    cin >> n;
    cout << "Following are the prime numbers smaller "
         << " than or equal to " << n << endl;
    SieveOfEratosthenes(n);
    cout << "\n";
    return 0;
}
   

using System;
using System.Linq;
namespace OpenGenus
{
	// Part of Cosmos by OpenGenus Foundation
	class Program
   	{
  		public static void Main(string[] args)
  		{
  			var random = new Random();
  			var n = random.Next(1, 1000);
  			var primes = SieveOfEratosthenes(n);
  			Console.WriteLine(__aSyNcId_<_dGxzqLGd__quot;Primes up to {n}\n");
  			Console.WriteLine(string.Join(",", primes));
  			Console.ReadLine();
  		}
  		private static int[] SieveOfEratosthenes(int n)
  		{
			// create number list from 0 to n
  			var numbers = Enumerable.Range(0, n + 1).Select(x => x).ToArray();
  			var lenRoot = Math.Sqrt(n);
			// go through all possible factors of numbers in the range bound inclusive by 2 and n
  			for (var i = 2; i <= lenRoot; i++)
  			{
				// skip numbers already blanked by a prime factor
  				if (numbers[i] == 0)
  					continue;
  				for (int j = i * i; j < numbers.Length; j += i)
  				{
					// blank out any multiple of i
					numbers[j] = 0;
  				}
  			}
			// return all numbers between 2 and n
			// these will be all primes in the range
  			return numbers.Where(x => x > 1).ToArray();
  		}
    }
}
   

/* Part of Cosmos by OpenGenus Foundation */
import java.util.Scanner;              //To take the input the scanner class has to be imported.
public class erathosthenes{
	public void sieve (int n) { 
	boolean checkPrime[] = new boolean [n+1];       //checkPrime array to mark the elements whether they are prime or not. 
	int a=2;
		for(int i=0; i<n; i++){         //initialises all elements of checkPrime to true
			checkPrime[i] = true;
		}
		for(int i=a ; i*i<=n ; i++){           //outer for loop is to check whether a particular element has been marked, if no then it is taken
			if(checkPrime[i] == true){
				for(int j=i*2 ; j<=n ; j=j+i){  // inner for loop marks the multiples of the element selected by the outer for loop
					checkPrime[j] = false;
				}
			}
		}
		for(int i=2 ; i<=n ; i++){
			if(checkPrime[i] == true)
				System.out.println(i+" ");
		}
	}
	public static void main(String [] args){
		System.out.println("Enter the upperBound:");
		Scanner s=new Scanner(System.in);
		int n=s.nextInt();
		erathosthenes ee = new erathosthenes();
		ee.sieve(n);
	}
}
   

   package main
import "fmt"
// Part of Cosmos by OpenGenus Foundation
func SieveOfEratosthenes(n int) []int {
	//Create an array of Boolean values indexed by
    //integers 2 to n, initially all set to true.
	integers := make([]bool, n+1)
	for i := 2; i < n+1; i++ {
		integers[i] = true
	}
	for i := 2; i*i <= n; i++ {
		if integers[i] == true {
			//Check all multiples of i
				for j := i * 2; j <= n; j += i {
					integers[j] = false
				}
		}
	}
		//Return all unchanged numbers (prime numbers) <= n
		var primes []int
		for i := 2; i <= n; i++ {
			if integers[i] == true {
				primes = append(primes, i)
			}
		}
		return primes
}
   

module Eratosthenes where
-- Part of Cosmos by OpenGenus Foundation
eratosthenes :: [Integer] -- A list of all prime numbers
eratosthenes = go [2..]
  where
    -- If we have something in the front of the list (x:xs),
    -- we know it wasn't filtered, so it's prime.
    -- Then, we filter the rest of the list to exclude multiples of
    -- that number.
    go (x:xs) = x : (go $ filter (\n -> n `mod` x /= 0) xs)
primes = eratosthenes
main = do
  n <- getLine
  print $ take (read n :: Int) primes
   

   class SieveOfEratosthenes {
    /**
    * @constructor
    * @param {number} max - max number to test up to
    * Part of Cosmos by OpenGenus Foundation
    */
    constructor(max) {
        this._max = max;
        this._sqrtMax = Math.ceil(Math.sqrt(this._max));
        // Get an array from number 2 up to max. Start from 2 because 0 and 1
        // are not primes and do not need to be evaluated.
        this._storage = Array.from({ length: max - 1 }, (k, v) => v + 2 );
    }
    _isPrime(num) {
        for (let i = 2; i < this._sqrtMax; i++) {
            if (num % i === 0 && num !== i) {
                return false;
            }
        }
        return true;
    }
    /**
    * start - determine all primes
    * @return {array} an array of all prime numbers from 2 to max.
    */
    start() {
        this._storage = this._storage.filter(num => {
            return this._isPrime(num);
        });
        return this._storage;
    }
}
////////////
// TESTS: //
////////////
// All valid prime numbers up to 1000
const primeNums = [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, 101, 103, 107, 109, 113, 127, 131, 137,
     139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223,
     227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307,
     311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397,
     401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487,
     491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593,
     599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677,
     683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787,
     797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883,
     887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997];
// Test cases:
// All test cases should return "test-X is true"
const testNums = [1, 30, 100, 300, 600, 1000]
testNums.forEach((max, idx) => {
    const sieve = new SieveOfEratosthenes(max);
    const allPrimes = sieve.start();
    const diff = allPrimes.filter(num => {
        return primeNums.indexOf(num) === -1;
    });
    console.log(`test-${idx} is ${diff.length === 0}`)
})
   

<?php
/**
 * Part of Cosmos by OpenGenus Foundation
 *
 * Find all prime numbers up to any given n using Sieve of Eratosthenes.
 *
 * @param int $n
 *
 * @return array|integer
 */
function sieveOfEratosthenes($n)
{
    if ($n <= 1) {
        return -1;
    }
    $array = array_fill_keys(range(2, $n), true);
    for ($i = 2; $i <= (int) sqrt($n); $i++) {
        if ($array[$i] === true) {
            for ($j = $i ** 2; $j <= $n; $j += $i) {
                $array[$j] = false;
            }
        }
    }
    return array_keys($array, true);
}
echo implode(', ', sieveOfEratosthenes(365));
   

import sys
# Part of Cosmos by OpenGenus Foundation
def sieve_erato(n):
    loops = 0
    numbers = set(range(2, n))
    for i in range(2, int(n ** 0.5) + 1):
        for j in range(i * 2, n, i):
            numbers.discard(j)
            loops += 1
    return sorted(numbers), loops
try:
    primes = sieve_erato(int(input().rstrip()))
except:
    sys.exit()
print(primes[0])
print("\nComputations {}".format(primes[1]))