Arrays and Accumulator Patterns

Where you are: Week 0 review > Arrays and accumulator patterns

Try This First

For the array {5, 2, 8, 1, 9, 3}, add up all six values in your head before reading on.

Before You Start

Check each box you can do from memory. A box you cannot check yet is not a problem; it points you to a quick refresher, not a grade.

• I can write a for loop that counts from 0 up to (but not including) a given number.
• I can trace through a loop body and state what the loop variable holds on each pass.
• I can declare and assign a variable before a loop and read its value after.

See Loops: for, while, and do-while for the full loop lesson.

What You Need To Walk In With

Walk into the next class able to state these:

• An array is a fixed-size, indexed group of values of one type. Indexes start at 0 and run to length - 1; xs.length is the count.
• An accumulator carries a running result across the loop: sum, count, min, or max. Declare it before the loop, update inside, read after.
• Seed a min or max from the first element (xs[0]), not from 0. Seeding from 0 fails when every value is positive (for a min) or negative (for a max).

You should be able to: write a sum, count, min, or max loop over an int[], and index an array correctly.

How It Works

Declaring and walking an array

int[] xs = {5, 2, 8, 1, 9, 3};
System.out.println(xs.length);   // 6
System.out.println(xs[0]);       // 5  (first element)
System.out.println(xs[5]);       // 3  (last element, length - 1)

An index outside 0 to length - 1 throws an error at runtime. Walk the array with an indexed loop:

for (int i = 0; i < xs.length; i++) {
    System.out.println(xs[i]);
}

The accumulator family

Each pattern declares a variable before the loop and updates it once per element:

int sum = 0;
int max = xs[0];               // seed from the first element
for (int i = 0; i < xs.length; i++) {
    sum = sum + xs[i];
    if (xs[i] > max) { max = xs[i]; }
}

A count adds 1 when a test passes; a min mirrors the max with <. The accumulator must be declared before the loop so it survives across iterations and is in scope after.

Worked Example: Predict, Then Check

int[] xs = {4, 9, 2};
int max = xs[0];
for (int i = 1; i < xs.length; i++) {
    if (xs[i] > max) { max = xs[i]; }
}
System.out.println(max);

Predict the output before reading on.

A Common Mistake

Seeding a min or max with 0 is a frequent bug. For the array {3, 7, 2, 5}, a min seeded at 0 never finds an element smaller than 0, so it returns 0, a value not even in the array. Seed from xs[0] and start the loop at index 1. (Source: BJP (Reges and Stepp), Ch 7.)

Go Deeper (optional)

For the curious: every accumulator is the same shape, a fold of the array into one value: start with a seed, combine it with each element, and read the result. Sum seeds with 0 and combines with plus; max seeds with the first element and combines with “keep the larger.” Seeing the shared shape makes a new accumulator (a product, a concatenation) easy to write.

Check Yourself

Close the notes and answer each one from memory, then reveal it. Pulling an idea back from memory is one of the strongest ways to make it stick.