🔢 Prime Numbers in C —
Logic, Flowchart & Three Approaches

#include <stdio.h>

/* Returns 1 if n is prime, 0 otherwise */
int isPrime(int n) {
    if (n < 2) return 0;        /* 0 and 1 are NOT prime         */
    if (n == 2) return 1;       /* 2 is the only even prime      */
    if (n % 2 == 0) return 0;  /* all other even → not prime    */

    /* Check odd divisors from 3 up to √n */
    for (int i = 3; i * i <= n; i += 2) {
        if (n % i == 0)
            return 0;           /* divisor found → not prime     */
    }
    return 1;                    /* survived all checks → prime   */
}

int main() {
    int n = 100;
    int count = 0;

    printf("Prime numbers from 1 to %d:\n", n);
    printf("--------------------------------\n");

    for (int num = 2; num <= n; num++) {
        if (isPrime(num)) {         /* call function — clean! */
            printf("%4d", num);
            count++;
            if (count % 10 == 0) printf("\n"); /* 10 per line */
        }
    }

    printf("\n--------------------------------\n");
    printf("Total primes found: %d\n", count);
    return 0;
}

#include <stdio.h>
#include <math.h>

/* Pointer version — writes result through *result pointer */
void checkPrime(const int *n, int *result) {
    int num = *n;                /* read value through pointer   */
    *result = 1;               /* assume prime via pointer      */

    if (num < 2)  { *result = 0; return; }
    if (num == 2) { *result = 1; return; }
    if (num % 2 == 0) { *result = 0; return; }

    for (int i = 3; i * i <= num; i += 2) {
        if (num % i == 0) {
            *result = 0;        /* write NOT PRIME through ptr  */
            return;
        }
    }
    /* *result stays 1 — prime */
}

/* Print array via pointer walk — no index used */
void printViaPtrWalk(const int *arr, int count) {
    const int *p   = arr;          /* pointer starts at arr[0]     */
    const int *end = arr + count;  /* one-past-last sentinel        */
    int  col = 0;

    while (p < end) {
        printf("%4d", *p);         /* dereference pointer           */
        p++;                        /* advance to next element       */
        if (++col % 10 == 0) printf("\n");
    }
}

int main() {
    int  n       = 100;
    int  storage[30];  /* there are 25 primes ≤ 100    */
    int  count   = 0;
    int  result  = 0;

    for (int num = 2; num <= n; num++) {
        checkPrime(&num, &result);  /* pass ADDRESSES — pointer API  */
        if (result)
            storage[count++] = num; /* save prime in array           */
    }

    printf("Primes 1-%d via pointer walk:\n", n);
    printf("--------------------------------\n");
    printViaPtrWalk(storage, count);

    printf("\n--------------------------------\n");
    printf("Count : %d\n", count);
    printf("Largest: %d\n", storage[count-1]);
    printf("Smallest: %d\n", storage[0]);

    /* Pointer arithmetic — sum of primes */
    int sum = 0;
    const int *p = storage;
    const int *e = storage + count;
    while(p < e) sum += *p++;
    printf("Sum    : %d\n", sum);
    return 0;
}

#include <stdio.h>
#include <string.h>

#define N 100

/* Build the sieve — marks composite numbers as 0 */
void buildSieve(int *mark, int n) {
    /* Step 1 — fill array with 1 (assume all prime) */
    for(int i = 0; i <= n; i++) mark[i] = 1;
    mark[0] = mark[1] = 0;      /* 0 and 1 not prime             */

    /* Step 2 — sieve: for each prime p, cross its multiples */
    for (int p = 2; p * p <= n; p++) {
        if (mark[p] == 1) {          /* p is still prime              */
            /* cross out p*p, p*p+p, p*p+2p ... */
            for (int j = p * p; j <= n; j += p)
                mark[j] = 0;          /* j is a multiple of p          */
        }
    }
}

/* Print primes using pointer walk — index via ptr arithmetic */
int printPrimesPtr(const int *mark, int n) {
    const int *p   = mark + 2;   /* start from index 2           */
    const int *end = mark + n + 1;/* one past mark[n]             */
    int  count = 0, col = 0;

    printf("Primes via sieve (1 to %d):\n", n);
    printf("-------------------------------\n");

    while (p < end) {
        if (*p == 1) {                /* marked prime                 */
            printf("%4d", (int)(p - mark)); /* index = number       */
            count++; col++;
            if (col % 10 == 0) printf("\n");
        }
        p++;                           /* advance pointer              */
    }
    return count;
}

/* Stats via pointer scan */
void sieveStats(const int *mark, int n) {
    const int *p = mark + 2;
    const int *e = mark + n + 1;
    int sum=0, first=-1, last=-1, cnt=0;
    while(p < e){
        if(*p){
            int num = (int)(p - mark);
            if(first == -1) first = num;
            last = num;
            sum += num; cnt++;
        }
        p++;
    }
    printf("\n-------------------------------\n");
    printf("Count   : %d\n",   cnt);
    printf("Smallest: %d\n",   first);
    printf("Largest : %d\n",   last);
    printf("Sum     : %d\n",   sum);
    printf("Average : %.2f\n", (float)sum/cnt);
}

int main() {
    int mark[N + 1];

    buildSieve(mark, N);       /* pass array as pointer */
    printPrimesPtr(mark, N);   /* pointer walk + ptr arithmetic */
    sieveStats(mark, N);
    return 0;
}