Array algorithms: max, count, search, average

Four classic array jobs

Most array work is one of four scans: find the maximum, count matches, search for a value, or take an average.
Each one is a single for loop over the array, with a variable that remembers something.
Once you know these four, most array problems are a small change to one of them.

Finding the maximum

Start by assuming the first item is the biggest: int best = a[0];.
Then look at the rest. If an item is bigger than best, it becomes the new best.
This works for negative numbers too, because you start from a real item, not 0.

Counting with a condition

A counter starts at 0 and adds 1 each time an item passes a test.
For example, count even numbers by testing a[i] % 2 == 0 inside the loop.
The counter's final value is your answer.

Linear search

To search, walk the array and compare each item to the target.
Return the index as soon as you find a match. If the loop ends with no match, return -1.
-1 is a common "not found" signal because it is never a valid index.

Average without integer-division bugs

Add all the items into an int total, then divide by n.
Dividing two ints drops the fraction, so cast: (double)total / n.
Return a double so the caller gets the exact average.

Now you try

Pass the array and its length n, and pick the right "remember" variable for each job.
Do not write a main — the checker provides one.

Complete int max(const int a[], int n) so it returns the largest item (assume n >= 1). Start from a[0] so negatives work. Do not write a main.

/* Return the largest of a[0..n-1] (n >= 1). Do not write main(). */
int max(const int a[], int n) {
    return 0;   /* start from a[0], not 0 */
}

Click Run to see the output here.

Complete int count_even(const int a[], int n) so it returns how many items are even. Use % 2. Do not write a main.

/* Count the even items of a[0..n-1]. Do not write main(). */
int count_even(const int a[], int n) {
    return 0;   /* test a[i] % 2 == 0 */
}

Click Run to see the output here.

Complete int index_of(const int a[], int n, int target) so it returns the index of the first target, or -1 if it is not there. Do not write a main.

/* Return the index of the first target, or -1. Do not write main(). */
int index_of(const int a[], int n, int target) {
    return -1;   /* return i as soon as a[i] == target */
}

Click Run to see the output here.

Complete double average(const int a[], int n) so it returns the average of the items (assume n >= 1). Cast to avoid integer division. Do not write a main.

/* Return the average of a[0..n-1] as a double. Do not write main(). */
double average(const int a[], int n) {
    return 0.0;   /* sum, then (double)total / n */
}

Click Run to see the output here.