Algorithms: Number Theory Tutorials and Code Examples - Page 8

Sieve of Eratosthenes in PHP

The sieve identifies all primes up to a limit by marking multiples of smaller primes.

php

function sieve_count(int $n): int {
    alg_require((($n >= 0) && ($n <= 1000000)));
    $composite = array_fill(0, alg_size(alg_add($n, 1)), 0);
    $p = 2;
    $multiple = 0;
    $count = 0;
    while (($p <= intdiv($n, $p))) {
        if (($composite[$p] == 0)) {
            $multiple = alg_mul($p, $p);
            while (($multiple <= $n)) {
                $composite[$multiple] = 1;
                $multiple = alg_add($multiple, $p);

Nov 15, 2026 PHP

Algorithms: Number Theory

Sieve of Eratosthenes in C#

The sieve identifies all primes up to a limit by marking multiples of smaller primes.

csharp

    static int sieve_count(int n) {
        checked {
            alg_require(((n >= 0) && (n <= 1000000)));
            int[] composite = new int[alg_size((n + 1))];
            int p = 2;
            int multiple = 0;
            int count = 0;
            while ((p <= (n / p))) {
                if ((composite[p] == 0)) {
                    multiple = (p * p);
                    while ((multiple <= n)) {
                        composite[multiple] = 1;

Nov 15, 2026 csharp

Algorithms: Number Theory

Sieve of Eratosthenes in C++

The sieve identifies all primes up to a limit by marking multiples of smaller primes.

cpp

int sieve_count(int n) {
    alg_require(((n >= 0) && (n <= 1000000)));
    std::vector<int> composite(alg_size(alg_add(n, 1)), 0);
    int p = 2;
    int multiple = 0;
    int count = 0;
    while ((p <= (n / p))) {
        if ((composite[p] == 0)) {
            multiple = alg_mul(p, p);
            while ((multiple <= n)) {
                composite[multiple] = 1;
                multiple = alg_add(multiple, p);

Nov 15, 2026 C++

Algorithms: Number Theory

Sieve of Eratosthenes in C

The sieve identifies all primes up to a limit by marking multiples of smaller primes.

c

int sieve_count(int n) {
    int alg_error = 0;
    int alg_result = INT_MIN;
    errno = 0;
    int *composite = NULL;
    if (!(((n >= 0) && (n <= 1000000)))) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }
    if (alg_error) { errno = ERANGE; alg_result = INT_MIN; goto alg_cleanup; }
    {
        int alg_length = alg_add(n, 1, &alg_error);
        if (alg_error) { errno = ERANGE; alg_result = INT_MIN; goto alg_cleanup; }
        if (alg_length < 0 || alg_length > 4000000) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }
        composite = calloc((size_t)(alg_length ? alg_length : 1), sizeof(*composite));

Nov 15, 2026 C

Algorithms: Number Theory

Sieve of Eratosthenes in Python

The sieve identifies all primes up to a limit by marking multiples of smaller primes.

python

def sieve_count(n: int) -> int:
    alg_require(type(n) is int and -2147483648 <= n <= 2147483647)
    alg_require(n >= 0 and n <= 1000000)
    composite: list[int] = [0] * alg_size(n + 1)
    p: int = 2
    multiple: int = 0
    count: int = 0
    while p <= n // p:
        if composite[p] == 0:
            multiple = p * p
            while multiple <= n:
                composite[multiple] = 1

Nov 15, 2026 python