Lab 4, every problem worked

Problem 1

Number classifier via loop

Enter a number: 452
Digits: 3
Sum: 11
Reversed: 254

One pass over the digits: count them, sum them, and build the reverse.

"In a single pass" is the whole point of the exercise: the temptation is to write three separate loops, one per answer. Resist it — every quantity you want can be updated inside the one loop, because each depends only on the digit currently in your hand.

#include <stdio.h>

int main(void)
{
    int n;
    printf("Enter a number: ");
    scanf("%d", &n);

    int digits = 0, sum = 0, reversed = 0;
    int temp = n;

    while (temp != 0) {
        int d = temp % 10;            // last digit
        digits++;                     // counter
        sum += d;                     // accumulator
        reversed = reversed * 10 + d; // builder — see below
        temp /= 10;                   // advance
    }

    printf("Digits: %d\n", digits);
    printf("Sum: %d\n", sum);
    printf("Reversed: %d\n", reversed);
    return 0;
}

% ./a.out
Enter a number: 452
Digits: 3
Sum: 11
Reversed: 254

The only line that isn't obvious is reversed = reversed * 10 + d. Multiplying by 10 shifts everything you have built so far one place to the left, leaving a hole in the units column; + d drops the new digit into that hole. Since digits arrive backwards, the number gets built backwards, which is exactly the reverse:

Problem 2

Decimal-to-binary converter and bit counter

Enter a positive integer: 23
Binary representation: 10111
Number of 1 bits: 4

Print the bits most-significant-first, then count the 1s.

Two loops. The first climbs: keep doubling while doubling still fits inside n, which leaves p holding the largest power of 2 that is ≤ n. The second descends from that power to 1, asking at each step "is this bit a 1?".

#include <stdio.h>

int main(void)
{
    int n;
    printf("Enter a positive integer: ");
    scanf("%d", &n);

    // 1. climb to the highest power of 2 that fits in n
    int p = 1;
    while (p * 2 <= n) {
        p *= 2;
    }

    // 2. walk back down, printing one bit per power
    int ones = 0;
    printf("Binary representation: ");
    while (p >= 1) {
        int bit = (n / p) % 2;
        printf("%d", bit);
        if (bit == 1) ones++;
        p /= 2;
    }
    printf("\n");
    printf("Number of 1 bits: %d\n", ones);
    return 0;
}

% ./a.out
Enter a positive integer: 23
Binary representation: 10111
Number of 1 bits: 4

p is the place value the loop is currently asking about — 16, then 8, 4, 2, 1 — not a bit number. On each pass, read (n / p) % 2 as: divide by the place value to bring that bit down into the units position (integer division throws away every bit below it), then take the units bit. Take the single pass where p = 4, for n = 23: 23/4 is 5 (not 5.75), 5 % 2 is 1 — so the 4s bit is set. The same pass for n = 22 gives 22/4 = 5, 5 % 2 = 1: the 4s bit of 22 (= 10110) is set too. For n = 19 (= 10011): 19/4 = 4, 4 % 2 = 0, not set. The full trace for 23, all five passes — the table you would sketch to convince an examiner (the p = 4 row is the example above):

Verified against other inputs: 1 → 1 (one bit); 8 → 1000 (one 1-bit); 255 → 11111111 (eight); 1000 → 1111101000 (six).

Problem 3

The digital root

Enter a number: 987
Intermediate sum: 24
Intermediate sum: 6
Digital root: 6

Sum the digits; if the result still has more than one digit, sum again; repeat.

#include <stdio.h>

int main(void)
{
    int n;
    printf("Enter a number: ");
    scanf("%d", &n);

    while (n > 9) {                  // more than one digit?
        int sum = 0, temp = n;
        while (temp != 0) {          // the digit pattern again
            sum += temp % 10;
            temp /= 10;
        }
        printf("Intermediate sum: %d\n", sum);
        n = sum;                     // the advance: shrink n
    }

    printf("Digital root: %d\n", n);
    return 0;
}

% ./a.out
Enter a number: 987
Intermediate sum: 24
Intermediate sum: 6
Digital root: 6

n > 9 is the compact way of saying "has more than one digit", and it is worth pausing on: single-digit numbers are exactly 0–9, so anything above 9 needs another round. Note the two nice consequences — feed it a number that is already a single digit (say 5) and the outer loop runs zero times, printing no intermediate sums and going straight to Digital root: 5. That is the zero-iteration boundary case, handled for free by putting the test at the top.

Verified: 987 → 24 → 6. 9999999 → 63 → 9. 5 → 5 with no intermediate line.

Problem 4

PIN validator with limited attempts

Enter PIN: 1111
Incorrect. Try again.
Enter PIN: 9999
Incorrect. Try again.
Enter PIN: 0000
Account locked. Too many failed attempts.

Enter PIN: 1111
Incorrect. Try again.
Enter PIN: 1234
Access granted!

Three attempts, then lock out; success exits immediately.

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

int main(void)
{
    const int CORRECT = 1234;
    int attempts = 0;
    bool unlocked = false;
    int entered;

    do {
        printf("Enter PIN: ");
        scanf("%d", &entered);
        attempts++;

        if (entered == CORRECT) {
            unlocked = true;                   // raise the flag
        } else if (attempts < 3) {
            printf("Incorrect. Try again.\n"); // don't say it on the last try
        }
    } while (!unlocked && attempts < 3);

    if (unlocked) printf("Access granted!\n");
    else printf("Account locked. Too many failed attempts.\n");
    return 0;
}

% ./a.out            % ./a.out
Enter PIN: 1111       Enter PIN: 1111
Incorrect. Try again. Incorrect. Try again.
Enter PIN: 9999       Enter PIN: 1234
Incorrect. Try again. Access granted!
Enter PIN: 0000
Account locked. Too many failed attempts.

Two details that separate a working program from a polished one, both visible in the sheet's own sample output. First, "Incorrect. Try again." does not appear after the third failure — "try again" would be a lie, since there is no again. That is what the else if (attempts < 3) buys you. Second, the loop condition carries both exit reasons, and the if after the loop asks which one fired. That flag-plus-check shape is the standard way to answer "why did the loop end?"

Problem 5

The smart guesser simulation

Target number is 714.
Guessing 500... Too low!
Guessing 750... Too high!
Guessing 625... Too low!
... [intermediate guesses omitted for brevity] ...
Guessing 714... Correct!

Found in 9 guesses.

Halve the range each time; count the guesses.

This is binary search, and the reason it is fast is worth one sentence: each wrong guess eliminates half of what remains, so 1000 candidates collapse to about 10 guesses — because doubling 1 ten times passes 1000. Guessing 1, 2, 3, … would take up to 1000.

#include <stdio.h>

int main(void)
{
    int target = 714;
    int low = 1, high = 1000;
    int guesses = 0;

    printf("Target number is %d.\n", target);

    while (low <= high) {
        int guess = (low + high) / 2;   // the midpoint
        guesses++;
        printf("Guessing %d... ", guess);

        if (guess == target) {
            printf("Correct!\n");
            break;
        } else if (guess < target) {
            printf("Too low!\n");
            low = guess + 1;            // answer is above the guess
        } else {
            printf("Too high!\n");
            high = guess - 1;           // answer is below the guess
        }
    }

    printf("\nFound in %d guesses.\n", guesses);
    return 0;
}

% ./a.out
Target number is 714.
Guessing 500... Too low!
Guessing 750... Too high!
Guessing 625... Too low!
Guessing 687... Too low!
Guessing 718... Too high!
Guessing 702... Too low!
Guessing 710... Too low!
Guessing 714... Correct!

Found in 8 guesses.

Problem 6

Approximating π with the Gregory–Leibniz series

Enter N: 10000
Approximate pi: 3.141493
Actual pi: 3.141593
Percentage error: 0.003183%

π/4 = 1 − 1/3 + 1/5 − 1/7 + …, times 4, with the percentage error.

The i-th term (counting from i = 0) has denominator 2i + 1 — that generates 1, 3, 5, 7, … exactly. The alternating sign is handled by a variable that multiplies by −1 each pass; that trick reappears constantly.

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

int main(void)
{
    int N;
    printf("Enter N: ");
    scanf("%d", &N);

    double sum = 0.0;
    int sign = 1;
    for (int i = 0; i < N; i++) {
        sum += sign * 1.0 / (2 * i + 1);  // note the 1.0 — see the trap
        sign = -sign;                     // flip for the next term
    }

    double approx = 4 * sum;
    double actual = acos(-1.0);
    double error = fabs(approx - actual) / actual * 100;

    printf("Approximate pi: %f\n", approx);
    printf("Actual pi: %f\n", actual);
    printf("Percentage error: %f%%\n", error);
    return 0;
}

Compile with gcc -Wall -o pi pi.c -lm — the -lm links the maths library that acos and fabs live in. Forgetting it gives a confusing "undefined symbol" error at the link stage, not a compile error.

% ./pi              % ./pi                % ./pi
Enter N: 100         Enter N: 10000         Enter N: 1000000
Approximate pi: 3.131593   3.141493              3.141592
Actual pi: 3.141593        3.141593              3.141593
Percentage error: 0.318302%  0.003183%            0.000032%

And there is the answer to the question the sheet actually asks. Multiplying the work by 100 divides the error by about 100 — one extra correct decimal place for every hundredfold increase in effort. This series is beautiful and useless for computing π; real algorithms converge far faster. That trade-off, accuracy against running time, is the point of the exercise.

Problem 7

Star pattern menu

Menu:
1. Right Triangle
2. Inverted Right Triangle
3. Square
Select pattern: 2
Enter size: 4

****
***
**
*

A switch chooses the pattern; nested loops draw it.

#include <stdio.h>

int main(void)
{
    int choice, n;
    printf("Menu:\n1. Right Triangle\n2. Inverted Right Triangle\n3. Square\n");
    printf("Select pattern: ");
    scanf("%d", &choice);
    printf("Enter size: ");
    scanf("%d", &n);
    printf("\n");

    switch (choice) {
        case 1:                                       // growing triangle
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= i; j++) printf("*");
                printf("\n");
            }
            break;
        case 2:                                       // shrinking triangle
            for (int i = n; i >= 1; i--) {
                for (int j = 1; j <= i; j++) printf("*");
                printf("\n");
            }
            break;
        case 3:                                       // square
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= n; j++) printf("*");
                printf("\n");
            }
            break;
        default:
            printf("Invalid choice.\n");
    }
    return 0;
}

% ./a.out
Select pattern: 2
Enter size: 4

****
***
**
*

Compare the three inner loops and nothing else changes: j <= i with i counting up gives the growing triangle; j <= i with i counting down gives the inverted one; j <= n gives the square. Every star-pattern question you will ever be asked is a variation on which expression sits in the inner loop's condition.

Debugging exercise 1

The table that stops at 9

int n = 5;
for (int i = 1; i < 10; i++) {
    printf("%d x %d = %d\n", n, i, n * i);
}

for (int i = 1; i < 10; i++)   // prints 5x1 … 5x9

Why: i < 10 is false as soon as i reaches 10, so the body never runs with i = 10 and the last line printed is 5 x 9 = 45 (confirmed by running it). Fix: i <= 10. This is the off-by-one error of §10.2.

Debugging exercise 2

The digit counter that freezes

int num = 459;
int count = 0;
while (num > 0) {
    count++;
}
printf("Digits: %d\n", count);

while (num > 0) {
    count++;
    num /= 10;   // ← THIS LINE IS MISSING
}

Why it freezes: nothing inside the body changes num, so num > 0 is true forever — 459 stays 459 and the loop never ends. It is the infinite loop of §10.1: the update step is missing. Fix: add num /= 10; inside the loop, and it prints Digits: 3.

If you ever run this by accident: Ctrl+C in the terminal kills a runaway program.

Debugging exercise 3

The sum that prints garbage

int sum;
for (int i = 1; i <= 5; i++) {
    sum = sum + i;
}
printf("Sum is %d\n", sum);

int sum;              // ← never given a starting value
for (int i = 1; i <= 5; i++) sum = sum + i;

Why: an uninitialised local variable in C contains whatever bytes happened to be sitting in that memory. The loop then correctly adds 15 to that garbage. Running the buggy version on this machine printed Sum is 221908503 — and it may print something different next run, or on a different machine, which is exactly what makes the bug nasty. Fix: int sum = 0;.

Debugging exercise 4

The triangle that came out square

int n = 4;
for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n; j++) {
        printf("*");
    }
    printf("\n");
}

for (int j = 1; j <= n; j++)   // every row gets n stars
for (int j = 1; j <= i; j++)   // row i gets i stars  ← the fix

Why: the inner loop's limit is n, a constant, so every row is the same length. Fix: exactly one character — change n to i in the inner condition, tying the row's length to the row's number. (That is the change the task asks for: one variable, one condition.) The picture in Problem 7 is this fix, drawn.

Debugging exercise 5

The thermostat glitch — 0.1 + 0.2

#include <stdio.h>

int main(void) {
    float current = 0.1;
    float adjustment = 0.2;
    float target = 0.3;

    if (current + adjustment == target) {
        printf("Calibrated\n");
    } else {
        printf("Drift detected\n");
    }

    if (current + adjustment == 0.3) {
        printf("Matches spec\n");
    } else {
        printf("Off spec\n");
    }

    return 0;
}

The output, run on a real compiler:

Calibrated
Off spec

The two checks look identical and disagree. Here is the whole story, in three facts:

1. Binary fractions can't hold 0.1, 0.2 or 0.3 exactly, any more than decimal can hold 1/3 exactly. Each is stored as the nearest representable value, so tiny errors enter the moment you type the number.
2. The first check compares a float with a float. The stored value of current + adjustment and the stored value of target both land on the same float: 0.30000001192092895508. Equal — so it prints Calibrated.
3. The second check compares against the literal 0.3, which is a double, not a float. The float sum is widened to double for the comparison, and the two disagree in the extra digits a double can see:

   float sum widened to double : 0.30000001192092895508
   double literal 0.3          : 0.29999999999999998890

   Not equal — so it prints Off spec.

The lesson: never compare floating-point values with ==. Compare with a tolerance:

#include <math.h>
if (fabs((current + adjustment) - target) < 1e-6) printf("Calibrated\n");

"Are they equal?" becomes "are they closer together than I care about?" — which is the only question that has a reliable answer in floating point. Integers are exact and may be compared with == freely; that is why loop counters are int.