Arrays, one rung at a time

#include <stdio.h>
int main(void)
{
    int marks[5] = {72, 85, 91, 68, 77};
    for (int i = 0; i < 5; i++) {
        printf("marks[%d] = %d\n", i, marks[i]);
    }
    marks[2] = 95;
    printf("After the change, marks[2] = %d\n", marks[2]);
    return 0;
}

The first line prints marks[0], not marks[1]. The fifth element is marks[4], and there is no marks[5].

#include <stdio.h>
int main(void)
{
    int a[5];
    printf("Enter 5 numbers: ");
    for (int i = 0; i < 5; i++) {
        scanf("%d", &a[i]);
    }
    printf("In reverse:");
    for (int i = 4; i >= 0; i--) {
        printf(" %d", a[i]);
    }
    printf("\n");
    return 0;
}

This is the first program in the course that has to remember input: the loop that reads is over before the loop that prints begins. Without an array you would need five variables. The & in &a[i] is the same & as in scanf("%d", &n), because a[i] is an ordinary int variable.

#include <stdio.h>
int main(void)
{
    int marks[5] = {72, 85, 91, 68, 77};
    int sum = 0;
    for (int i = 0; i < 5; i++) {
        sum += marks[i];
    }
    double average = (double) sum / 5;
    printf("Sum = %d, average = %.2f\n", sum, average);
    return 0;
}

Without the (double) cast, 393 / 5 divides two ints and gives 78. Storing that result in a double afterwards doesn't help: the fraction is lost at the moment of division.

#include <stdio.h>
int main(void)
{
    int marks[5] = {72, 85, 91, 68, 77};
    int count = 0;
    for (int i = 0; i < 5; i++) {
        if (marks[i] >= 75) {
            count++;
        }
    }
    printf("%d of 5 students scored 75 or more\n", count);
    return 0;
}

Check by hand: 85, 91 and 77 pass, and 72 and 68 don't, so the count is 3. Always check a count this way on data small enough to count yourself.

#include <stdio.h>
int main(void)
{
    int marks[5] = {72, 85, 91, 68, 77};
    int minVal = marks[0], maxVal = marks[0];
    for (int i = 1; i < 5; i++) {
        if (marks[i] < minVal) minVal = marks[i];
        if (marks[i] > maxVal) maxVal = marks[i];
    }
    printf("Lowest = %d, highest = %d\n", minVal, maxVal);
    return 0;
}

Why not start minVal at 0? Every mark is bigger than 0, so the minimum would come out as 0, a value that isn't even in the array. marks[0] is always a real candidate. Use two ifs here, not if … else if: one element can update both.

#include <stdio.h>
int main(void)
{
    int marks[5] = {72, 85, 91, 68, 77};
    int maxIdx = 0;
    for (int i = 1; i < 5; i++) {
        if (marks[i] > marks[maxIdx]) {
            maxIdx = i;
        }
    }
    printf("Student %d topped with %d\n", maxIdx, marks[maxIdx]);
    return 0;
}

Tracking the index is the key step for selection sort in Rung 6. There, you find the position of the smallest element so you can swap it into place. Knowing only its value would not be enough.

#include <stdio.h>

char grade(int mark);

int main(void)
{
    int marks[5] = {72, 85, 91, 68, 77};
    for (int i = 0; i < 5; i++) {
        printf("%d -> %c\n", marks[i], grade(marks[i]));
    }
    return 0;
}

char grade(int mark)
{
    if (mark >= 90) return 'A';
    if (mark >= 80) return 'B';
    if (mark >= 70) return 'C';
    if (mark >= 60) return 'D';
    return 'F';
}

The function needs no else: each return ends the function immediately, so a mark of 91 never reaches the >= 80 test. Delete the prototype line and clang refuses to compile: call to undeclared function 'grade'.

#include <stdio.h>

int addBonus(int mark, int bonus);

int main(void)
{
    int marks[5] = {72, 85, 97, 68, 77};
    for (int i = 0; i < 5; i++) {
        marks[i] = addBonus(marks[i], 5);
    }
    for (int i = 0; i < 5; i++) {
        printf("%d ", marks[i]);
    }
    printf("\n");
    return 0;
}

int addBonus(int mark, int bonus)
{
    mark = mark + bonus;
    if (mark > 100) mark = 100;
    return mark;
}

Inside addBonus, the line mark = mark + bonus changes only the function's own copy. That's pass-by-value from Lecture 7. Replace the loop body with just addBonus(marks[i], 5); and the array prints unchanged: 72 85 97 68 77. The marks[i] = … in front of the call is what saves the result.

#include <stdio.h>
int main(void)
{
    int marks[5] = {72, 85, 91, 68, 77};
    int target, foundIndex = -1;
    printf("Search for: ");
    scanf("%d", &target);
    for (int i = 0; i < 5; i++) {
        if (marks[i] == target) {
            foundIndex = i;
            break;
        }
    }
    if (foundIndex == -1)
        printf("%d is not in the array\n", target);
    else
        printf("%d found at index %d\n", target, foundIndex);
    return 0;
}

Why −1 and not 0? Index 0 is a real position; 68 might be sitting there. −1 is a sentinel, a value no genuine answer can take. The break is there only for speed. Remove it and you still get the right answer here, but you then find the last match instead of the first.

#include <stdio.h>
int main(void)
{
    int scores[8] = {55, 90, 72, 90, 61, 45, 90, 78};
    int target, count = 0;
    printf("Count how many times: ");
    scanf("%d", &target);
    for (int i = 0; i < 8; i++) {
        if (scores[i] == target) {
            count++;
        }
    }
    printf("%d appears %d time(s)\n", target, count);
    return 0;
}

This answers activity question 3. A search can stop at its first match, but a count cannot, because the third 90 is at index 6, near the end. Put a break in and the answer becomes 1.

#include <stdio.h>
int main(void)
{
    int a[8] = {12, 19, 23, 31, 44, 58, 67, 80};
    int target, left = 0, right = 7, foundIndex = -1;
    printf("Search for: ");
    scanf("%d", &target);
    while (left <= right) {
        int mid = left + (right - left) / 2;
        printf("left=%d right=%d mid=%d a[mid]=%d\n", left, right, mid, a[mid]);
        if (a[mid] == target) {
            foundIndex = mid;
            break;
        } else if (a[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    if (foundIndex == -1)
        printf("%d is not in the array\n", target);
    else
        printf("%d found at index %d\n", target, foundIndex);
    return 0;
}

This is the guessing game from Lab 4 Problem 5 again, now with array positions instead of numbers. Search for 30 and the range closes in until left passes right, which is how the loop knows 30 isn't there. The + 1 and - 1 matter: without them the range can stop shrinking, and the loop never ends.

#include <stdio.h>
int main(void)
{
    int a[6] = {10, 20, 30, 40, 50, 60};
    int n = 6;
    for (int i = 0; i < n / 2; i++) {
        int temp = a[i];
        a[i] = a[n - 1 - i];
        a[n - 1 - i] = temp;
    }
    for (int i = 0; i < n; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");
    return 0;
}

Why three lines? Write a[i] = a[n-1-i] first and the old a[i] is gone, so temp keeps it safe. Run the loop to i < n instead and every pair gets swapped twice, which puts the array back where it started.

#include <stdio.h>
int main(void)
{
    int a[5] = {68, 72, 85, 77, 91};
    int n = 5;
    for (int pass = 0; pass < n - 1; pass++) {
        int swapped = 0;
        for (int i = 0; i < n - 1 - pass; i++) {
            if (a[i] > a[i + 1]) {
                int temp = a[i];
                a[i] = a[i + 1];
                a[i + 1] = temp;
                swapped = 1;
            }
        }
        printf("After pass %d:", pass + 1);
        for (int k = 0; k < n; k++) printf(" %d", a[k]);
        printf("\n");
        if (swapped == 0) {
            printf("No swaps - already sorted, stopping early\n");
            break;
        }
    }
    return 0;
}

Run it on the lecture's data, {72, 85, 91, 68, 77}, and it needs all four passes. The array is already sorted after pass 3, but it takes pass 4, with zero swaps, to show that. The flag earns its keep on nearly sorted data like this one: two passes instead of four. And why i < n - 1 - pass? The inner loop reads a[i + 1], so at i = n - 1 it would go past the end.

#include <stdio.h>
int main(void)
{
    int a[5] = {72, 85, 91, 68, 77};
    int n = 5;
    for (int i = 0; i < n - 1; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (a[j] < a[minIdx]) minIdx = j;
        }
        int temp = a[i];
        a[i] = a[minIdx];
        a[minIdx] = temp;
        printf("After pass %d:", i + 1);
        for (int k = 0; k < n; k++) printf(" %d", a[k]);
        printf("\n");
    }
    return 0;
}

Pass 4 changes nothing: the minimum of {85, 91} is already at the front, so a[3] is swapped with itself. This matches Lecture 8's trace ("sorted after 3 swaps"): the code still runs a fourth pass, but that swap doesn't move anything.

#include <stdio.h>
int main(void)
{
    int g[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
    for (int r = 0; r < 3; r++) {
        int rowSum = 0;
        for (int c = 0; c < 4; c++) {
            printf("%4d", g[r][c]);
            rowSum += g[r][c];
        }
        printf("  | row sum %d\n", rowSum);
    }
    return 0;
}

Where rowSum = 0 goes is the whole lesson. Inside the outer loop, it restarts for every row. Move it above both loops and you get running totals instead: 10, 36, 78.

#include <stdio.h>
int main(void)
{
    int A[2][3] = {{1, 2, 3}, {4, 5, 6}};
    int T[3][2];
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            T[j][i] = A[i][j];
        }
    }
    for (int r = 0; r < 3; r++) {
        for (int c = 0; c < 2; c++) {
            printf("%4d", T[r][c]);
        }
        printf("\n");
    }
    return 0;
}

Row 0 of A (1 2 3) became column 0 of T. Declaring T[2][3] by mistake means T[j][i] reaches T[2][…], a row that doesn't exist. That is out of bounds, and C won't stop you.

#include <stdio.h>
int main(void)
{
    int A[2][2] = {{1, 2}, {3, 4}};
    int B[2][2] = {{5, 6}, {7, 8}};
    int C[2][2];
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            C[i][j] = A[i][j] + B[i][j];
        }
    }
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            printf("%4d", C[i][j]);
        }
        printf("\n");
    }
    return 0;
}

This matches the table on Lecture 8 slide 26. Matrix multiplication (slide 27) needs a third loop to add up products. The lecture only shows its shape, so don't drill it until a lab asks for it.