Conditional Mapping and Type Safety

Translating numeric ranges in to categorical outputs requires careful control flow management. The following implemantation maps an integer score to a letter grade using a switch statement.

#include <stdio.h>

char evaluate_grade(int numeric_score) {
    char rank;
    switch (numeric_score / 10) {
        case 10:
        case 9:  rank = 'A'; break;
        case 8:  rank = 'B'; break;
        case 7:  rank = 'C'; break;
        case 6:  rank = 'D'; break;
        default: rank = 'F';
    }
    return rank;
}

int main(void) {
    int input_val;
    while (scanf("%d", &input_val) != EOF) {
        printf("Score: %3d | Grade: %c\n", input_val, evaluate_grade(input_val));
    }
    return 0;
}

When designing branch structures, omitting the break keyword triggers fall-through behavior, causing unintended execution of subsequent cases. Additionally, assigning double-quoted literals to a char variable is invalid; single quotes must be used for character constants, while double quotes denote null-terminated string arrays.

Iterative Digit Aggregation

Extracting and summing individual digits relies on repeated modulo and division operations. The iterative approach continuously isolates the least significant digit until the value is exhausted.

#include <stdio.h>

int calculate_digit_sum(int value) {
    int accumulator = 0;
    int working_val = (value < 0) ? -value : value;
    while (working_val != 0) {
        accumulator += working_val % 10;
        working_val /= 10;
    }
    return accumulator;
}

int main(void) {
    int n, result;
    printf("Input integer: ");
    while (scanf("%d", &n) != EOF) {
        result = calculate_digit_sum(n);
        printf("Original: %d | Sum: %d\n\n", n, result);
    }
    return 0;
}

This method operates in $O(\log_{10} n)$ time complexity and avoids the overhead of stack frames asscoiated with recursive implementations.

Divide-and-Conquer Exponentiation

Computing $x^n$ efficiently can be achieved through recursive exponentiation by squaring, reducing the time complexity from linear to logarithmic.

#include <stdio.h>

int fast_exponentiate(int base, int exp) {
    if (exp == 0) return 1;
    if (exp == 1) return base;
    
    if (exp % 2 == 0) {
        int partial = fast_exponentiate(base, exp / 2);
        return partial * partial;
    } else {
        return base * fast_exponentiate(base, exp - 1);
    }
}

int main(void) {
    int x, n, res;
    printf("Enter base and exponent: ");
    while (scanf("%d %d", &x, &n) != EOF) {
        res = fast_exponentiate(x, n);
        printf("%d^%d = %d\n\n", x, n, res);
    }
    return 0;
}

The algorithm splits even exponents, squares the intermediate result, and handles odd exponents by multiplying the base once before reducing the power.

Prime Pair Enumeration

Identifying twin primes (pairs differing by 2) requires an optimized primality test. Checking divisors only up to the square root of the target number significantly improves performance.

#include <stdio.h>
#include <stdbool.h>

bool is_prime_candidate(int num) {
    if (num <= 1) return false;
    for (int d = 2; d * d <= num; d++) {
        if (num % d == 0) return false;
    }
    return true;
}

int main(void) {
    int pair_counter = 0;
    printf("Twin prime sequences below 100:\n");
    for (int val = 2; val <= 98; val++) {
        if (is_prime_candidate(val) && is_prime_candidate(val + 2)) {
            printf("(%d, %d)\n", val, val + 2);
            pair_counter++;
        }
    }
    printf("Total matching pairs: %d\n", pair_counter);
    return 0;
}

Binomial Coefficient: Recursive vs Iterative

Calculating combinations $C(n, m)$ demonstrates the trade-offs between recursive state management and iterative arithmetic accumulation.

Recursive Implementation:

#include <stdio.h>

int comb_recursive(int n, int k) {
    if (k == 0 || k == n) return 1;
    if (k > n) return 0;
    return comb_recursive(n - 1, k - 1) + comb_recursive(n - 1, k);
}

Iterative Implementation:

#include <stdio.h>

long long comb_iterative(int n, int k) {
    if (k < 0 || k > n) return 0;
    if (k == 0 || k == n) return 1;
    if (k > n / 2) k = n - k;
    
    long long res = 1;
    for (int i = 1; i <= k; i++) {
        res = res * (n - i + 1) / i;
    }
    return res;
}

int main(void) {
    int n, m;
    printf("Enter n and m: ");
    while (scanf("%d %d", &n, &m) != EOF) {
        printf("Recursive: %d | Iterative: %lld\n\n", comb_recursive(n, m), comb_iterative(n, m));
    }
    return 0;
}

The iterative version prevents stack overflow for large inputs by using multiplicative updates and symmetry optimization ($C(n, k) = C(n, n-k)$).

Multi-Parameter Greatest Common Divisor

Extending the Euclidean algorithm to three integers involves computing the GCD of the first two values, then applying the result to the third.

#include <stdio.h>

int compute_gcd_pair(int a, int b) {
    while (b != 0) {
        int remainder = a % b;
        a = b;
        b = remainder;
    }
    return a;
}

int compute_gcd_triple(int x, int y, int z) {
    return compute_gcd_pair(compute_gcd_pair(x, y), z);
}

int main(void) {
    int a, b, c, result;
    printf("Input three integers: ");
    while (scanf("%d %d %d", &a, &b, &c) != EOF) {
        result = compute_gcd_triple(a, b, c);
        printf("GCD: %d\n\n", result);
    }
    return 0;
}

Structured Console Output Generation

Rendering geometric ASCII patterns requires synchronized nested loops for horizontal spacing and vertical progression.

#include <stdio.h>

void render_figure_pyramid(int height) {
    for (int level = 0; level < height; level++) {
        int figures_per_line = (level * 2) + 1;
        int indentation = height - level - 1;
        
        for (int pad = 0; pad < indentation; pad++) printf("   ");
        for (int fig = 0; fig < figures_per_line; fig++) printf(" O  ");
        printf("\n");
        
        for (int pad = 0; pad < indentation; pad++) printf("   ");
        for (int fig = 0; fig < figures_per_line; fig++) printf("<H> ");
        printf("\n");
        
        for (int pad = 0; pad < indentation; pad++) printf("   ");
        for (int fig = 0; fig < figures_per_line; fig++) printf("I I ");
        printf("\n\n");
    }
}

int main(void) {
    int n;
    printf("Pyramid height: ");
    scanf("%d", &n);
    render_figure_pyramid(n);
    return 0;
}

The indentation decreases linearly as the row index increases, while the figure count follows an odd-number arithmetic progression. Proper spacing ensures alignment across multiple lines.