Implementing Array Algorithms

In Topic 2.9 you added up values as a loop produced them: numbers from a loop control variable, or numbers read one at a time from a Scanner. Once a value was added, it was gone. An array changes that. All the values sit in the array at once, so a program can add them up, then go back and look at them again, compare neighbors, or move them around. This chapter collects the standard array algorithms: well-known traversals that answer the questions programmers ask about a list of values again and again. Each one is a pattern you already know from Topic 2.9 or 2.10, now fed by a traversal from Topic 4.4.

The first two questions are “What is the total?” and “What is the average?” The accumulator from Topic 2.9 still does the work: start a total at 0 before the loop, add one element on each pass, and use the total after the loop. The only new part is where the values come from. Instead of reading them, the loop visits each element of the array.

There is a bonus. In Topic 2.9 you needed a separate counter to know how many values you had added. An array already knows: values.length is the number of elements. So the average is the sum divided by the length.

int[] sales = {12, 30, 8, 25, 16};
int total = 0;
for (int amount : sales)
{
    total += amount;
}
System.out.println(total);
double average = (double) total / sales.length;
System.out.println(average);

91
18.2

Now change two things: the element type and the kind of loop. When the array holds double values, the sum is already a double, so no cast is needed. And an indexed for loop (Topic 4.4) does the same job as the enhanced for loop; it reaches each element through its index instead.

double[] lapTimes = {9.5, 10.25, 8.75, 11.0};
double sum = 0.0;
for (int i = 0; i < lapTimes.length; i++)
{
    sum += lapTimes[i];
}
System.out.println(sum);
System.out.println(sum / lapTimes.length);

39.5
9.875

The length of an array can be zero (for example, int[] none = {};). For an empty array the total is 0, but there is no average: dividing by a length of 0 makes no sense. As with the counter in Topic 2.9, check that the length is greater than 0 before you divide when an empty array is possible.

int[] sales = {12, 30, 8, 25, 16};
int total = 0;
for (int i = 1; i < sales.length; i++)
{
    total += sales[i];
}
System.out.println(total);

int[] points = {4, 7, 1, 9, 6};
int total = 0;
for (int i = 0; i < points.length; i += 2)
{
    total += points[i];
}
System.out.println(total);

Which day was warmest? Which store has the lowest price? These ask for the maximum or minimum element of an array. The plan is the best-so-far idea from Topic 2.9: remember the best value seen so far, and replace it whenever the current value beats it.

An array makes the starting value easy. The safest start is a real piece of data, and the first element, values[0], is always there (as long as the array is not empty). Because element 0 is already the best so far, the loop can begin at index 1.

int[] temps = {58, 64, 61, 70, 66};
int warmest = temps[0];
for (int i = 1; i < temps.length; i++)
{
    if (temps[i] > warmest)
    {
        warmest = temps[i];
    }
}
System.out.println(warmest);

70

Often you need to know where the minimum or maximum is, not only what it is: which day, which store. An array makes that natural, because every element has an index. Instead of remembering the best value, remember the best index. The value is then always available as values[bestIndex].

int[] prices = {42, 35, 50, 35, 47};
int minIndex = 0;
for (int i = 1; i < prices.length; i++)
{
    if (prices[i] < prices[minIndex])
    {
        minIndex = i;
    }
}
System.out.println(minIndex);
System.out.println(prices[minIndex]);

1
35

An enhanced for loop can find the minimum or maximum value, but it cannot find the index, because its variable holds a copy of the element and no position. When the question asks “where,” use an indexed loop.

int[] temps = {58, 64, 61, 70, 66};
int maxIndex = 0;
for (int i = 1; i < temps.length; i++)
{
    if (temps[i] > maxIndex)
    {
        maxIndex = i;
    }
}
System.out.println(maxIndex);
System.out.println(temps[maxIndex]);

4
66

if (temps[i] > temps[maxIndex])

int smallest = 0;
for (int v : values)
{
    if (v < smallest)
    {
        smallest = v;
    }
}

How many students passed? How many days were below freezing? These ask for the number of elements that have a property: a condition that is either true or false for each element, such as “at least 65” or “even.” The counter from Topic 2.9 answers them. Start a count at 0 before the traversal, and add one inside an if statement only when the current element has the property.

int[] scores = {72, 58, 90, 65, 81, 49};
int passing = 0;
for (int score : scores)
{
    if (score >= 65)
    {
        passing++;
    }
}
System.out.println(passing);

4

Because an array keeps its values, the property can depend on something that is known only after a first traversal. “How many days were warmer than average?” needs the average before any counting can start. With an array, that is two traversals of the same data, one after the other.

int[] temps = {58, 64, 61, 70, 66};
int total = 0;
for (int t : temps)
{
    total += t;
}
double average = (double) total / temps.length;
System.out.println(average);
int aboveCount = 0;
for (int t : temps)
{
    if (t > average)
    {
        aboveCount++;
    }
}
System.out.println(aboveCount);

63.8
3

int[] nums = {3, 8, 5, 6, 7};
int evens = 0;
for (int i = 0; i < nums.length; i++)
{
    if (i % 2 == 0)
    {
        evens++;
    }
}
System.out.println(evens);

int[] nums = {3, 8, 5, 6, 7};
int evens = 0;
for (int i = 0; i < nums.length; i++)
{
    if (nums[i] % 2 == 0)
    {
        evens++;
    }
}
System.out.println(evens);

int[] ages = {12, 25, 10, 19, 31, 20};
int teens = 0;
for (int age : ages)
{
    if (age > 10 && age <= 20)
    {
        teens++;
    }
}
System.out.println(teens);

public class CountInsideLoop
{
    public static void main(String[] args)
    {
        int[] goals = {0, 2, 0, 1, 0};
        for (int g : goals)
        {
            int shutouts = 0;
            if (g == 0)
            {
                shutouts++;
            }
        }
        System.out.println(shutouts);
    }
}

int shutouts = 0;
for (int g : goals)
{
    if (g == 0)
    {
        shutouts++;
    }
}
System.out.println(shutouts);

Some questions want a yes or no instead of a number. Is any account overdrawn? Did every student pass? In Topic 2.10 you answered these about the characters of a string with a flag: a boolean that starts with one value and switches when the loop finds something. The same two patterns work on an array.

• At least one element has the property: start the flag at false (“none found yet”) and set it to true when an element has the property.
• All elements have the property: start the flag at true (“no problem found yet”) and set it to false when an element does not have the property.

In both cases, once the flag switches, nothing switches it back, and the answer is read only after the loop.

int[] balances = {120, 45, -10, 300};
boolean anyOverdrawn = false;
for (int balance : balances)
{
    if (balance < 0)
    {
        anyOverdrawn = true;
    }
}
System.out.println(anyOverdrawn);

true

Inside a method there is a shorter way. As soon as the answer is known, the method can return it, and a return statement ends the method at once (Topic 3.5). For “all,” the answer is known to be false the moment one element fails. The answer can be true only after every element has been checked, so return true; goes after the loop.

public class AllPassing
{
    public static boolean allPassing(int[] scores)
    {
        for (int score : scores)
        {
            if (score < 65)
            {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args)
    {
        int[] teamA = {80, 72, 91, 65};
        int[] teamB = {88, 50, 94, 70};
        int[] noScores = {};
        System.out.println(allPassing(teamA));
        System.out.println(allPassing(teamB));
        System.out.println(allPassing(noScores));
    }
}

true
false
true

public class AllPassingBug
{
    public static boolean allPassing(int[] scores)
    {
        for (int score : scores)
        {
            if (score < 65)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        return true;
    }

    public static void main(String[] args)
    {
        int[] teamB = {88, 50, 94, 70};
        System.out.println(allPassing(teamB));
    }
}

public class AllEvenChoices
{
    public static boolean choiceA(int[] nums)
    {
        boolean allEven = false;
        for (int n : nums)
        {
            if (n % 2 == 0)
            {
                allEven = true;
            }
        }
        return allEven;
    }

    public static boolean choiceB(int[] nums)
    {
        boolean allEven = true;
        for (int n : nums)
        {
            if (n % 2 != 0)
            {
                allEven = false;
            }
        }
        return allEven;
    }

    public static boolean choiceC(int[] nums)
    {
        boolean allEven = true;
        for (int n : nums)
        {
            if (n % 2 == 0)
            {
                allEven = true;
            }
            else
            {
                allEven = false;
            }
        }
        return allEven;
    }

    public static boolean choiceD(int[] nums)
    {
        boolean allEven = false;
        for (int n : nums)
        {
            if (n % 2 != 0)
            {
                allEven = false;
            }
        }
        return allEven;
    }

    public static void main(String[] args)
    {
        int[] mixed = {4, 2, 7};
        int[] evens = {4, 6, 2};
        int[] oddFirst = {3, 6, 2};
        System.out.println(choiceA(mixed) + " " + choiceA(evens) + " " + choiceA(oddFirst));
        System.out.println(choiceB(mixed) + " " + choiceB(evens) + " " + choiceB(oddFirst));
        System.out.println(choiceC(mixed) + " " + choiceC(evens) + " " + choiceC(oddFirst));
        System.out.println(choiceD(mixed) + " " + choiceD(evens) + " " + choiceD(oddFirst));
    }
}

true true true
false true false
false true true
false false false

public class AnyLongWord
{
    public static boolean anyLonger(String[] words, int limit)
    {
        for (String w : words)
        {
            System.out.println("checking " + w);
            if (w.length() > limit)
            {
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args)
    {
        String[] words = {"cat", "giraffe", "ox", "elephant"};
        System.out.println(anyLonger(words, 5));
        System.out.println(anyLonger(words, 8));
    }
}

checking cat
checking giraffe
true
checking cat
checking giraffe
checking ox
checking elephant
false

Did the step count go up from one day to the next? Did the same number come up twice in a row? These questions are about consecutive pairs: two elements that sit next to each other, at indices i and i + 1. An array of five elements has four such pairs:

index:    0      1      2      3      4
        4000   5200   5100   6000   7500
        \_____/\_____/\_____/\_____/
   pair:   0      1      2      3

Pair i is values[i] and values[i + 1]. The last pair starts at index 3, one before the last index, because its partner, index 4, is the last element. So the loop must stop one index early: i < values.length - 1. Going any further would ask for values[i + 1] past the end of the array.

int[] steps = {4000, 5200, 5100, 6000, 7500};
int increases = 0;
for (int i = 0; i < steps.length - 1; i++)
{
    if (steps[i + 1] > steps[i])
    {
        increases++;
    }
}
System.out.println(increases);

3

There is a second common way to write the same traversal: start at index 1 and pair each element with the one before it, values[i - 1] and values[i]. Now the loop can run all the way to the last index, i < values.length, because i - 1 never drops below 0. This example also combines pairs with the maximum algorithm from 4.5.2: it finds the biggest rise from one day to the next.

int[] temps = {61, 58, 66, 70, 63};
int biggestRise = temps[1] - temps[0];
int riseDay = 1;
for (int i = 2; i < temps.length; i++)
{
    int rise = temps[i] - temps[i - 1];
    if (rise > biggestRise)
    {
        biggestRise = rise;
        riseDay = i;
    }
}
System.out.println(biggestRise);
System.out.println(riseDay);

8
2

public class PairsOutOfBounds
{
    public static void main(String[] args)
    {
        int[] steps = {4000, 5200, 5100, 6000, 7500};
        int increases = 0;
        for (int i = 0; i < steps.length; i++)
        {
            if (steps[i + 1] > steps[i])
            {
                increases++;
            }
        }
        System.out.println(increases);
    }
}

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
	at PairsOutOfBounds.main(PairsOutOfBounds.java:9)

int[] rolls = {3, 3, 5, 5, 5, 2};
int repeats = 0;
for (int i = 0; i < rolls.length - 1; i++)
{
    if (rolls[i] == rolls[i + 1])
    {
        repeats++;
    }
}
System.out.println(repeats);

public class InOrderCheck
{
    public static boolean inOrder(int[] values)
    {
        for (int i = 1; i < values.length; i++)
        {
            if (values[i] < values[i - 1])
            {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args)
    {
        int[] a = {2, 5, 5, 9};
        int[] b = {2, 5, 4, 9};
        int[] c = {7};
        System.out.println(inOrder(a));
        System.out.println(inOrder(b));
        System.out.println(inOrder(c));
    }
}

A raffle must not sell the same ticket number twice. A seating chart must not list a student in two seats. Each question asks whether an array contains a duplicate: a value that appears at two or more different indices.

Consecutive pairs are not enough, because the two copies may be far apart. To be sure, every element must be compared with every other element. Think of a group of people shaking hands: the first person shakes hands with everyone after them, then the second person shakes hands with everyone after them, and so on. Nobody shakes their own hand, and no two people shake hands twice.

That plan is a nested loop (Topic 2.11). The outer loop picks one element, index i. The inner loop compares it with every element after it, so j starts at i + 1.

for (int i = 0; i < values.length; i++)
{
    for (int j = i + 1; j < values.length; j++)
    {
        // compare values[i] with values[j]
    }
}

Starting j at i + 1 does two jobs. It skips j == i, so an element is never compared with itself. And it skips the indices before i, whose pairs were already compared on an earlier pass of the outer loop.

int[] tickets = {17, 42, 8, 42, 3};
boolean hasDuplicate = false;
for (int i = 0; i < tickets.length; i++)
{
    for (int j = i + 1; j < tickets.length; j++)
    {
        if (tickets[i] == tickets[j])
        {
            hasDuplicate = true;
            System.out.println("Match at " + i + " and " + j);
        }
    }
}
System.out.println(hasDuplicate);

Match at 1 and 3
true

Answering “no duplicates” is harder than answering “yes,” for the same reason “all” was harder than “at least one” in 4.5.4: one match proves a duplicate, but proving there is none takes every comparison. This version counts the comparisons.

int[] codes = {5, 9, 2, 7};
int comparisons = 0;
boolean hasDuplicate = false;
for (int i = 0; i < codes.length; i++)
{
    for (int j = i + 1; j < codes.length; j++)
    {
        comparisons++;
        if (codes[i] == codes[j])
        {
            hasDuplicate = true;
        }
    }
}
System.out.println(hasDuplicate);
System.out.println(comparisons);

false
6

int[] codes = {5, 9, 2, 7};
boolean hasDuplicate = false;
for (int i = 0; i < codes.length; i++)
{
    for (int j = 0; j < codes.length; j++)
    {
        if (codes[i] == codes[j])
        {
            hasDuplicate = true;
        }
    }
}
System.out.println(hasDuplicate);

int[] nums = {2, 7, 2, 2};
int pairs = 0;
for (int i = 0; i < nums.length; i++)
{
    for (int j = i + 1; j < nums.length; j++)
    {
        if (nums[i] == nums[j])
        {
            pairs++;
        }
    }
}
System.out.println(pairs);

int[] colors = {4, 1, 4};
boolean twoInARow = false;
for (int i = 0; i < colors.length - 1; i++)
{
    if (colors[i] == colors[i + 1])
    {
        twoInARow = true;
    }
}
System.out.println(twoInARow);

A line of people moves up when the person at the front is served. A scrolling sign moves every letter one place to the left, and the letter that falls off the front reappears at the back. Both move every element of an array one position. The difference is what happens to the element that falls off the end.

• Shifting moves every element one position left (toward index 0) or right. The element pushed off the end is lost, and the empty spot at the other end gets a fill value, such as 0.
• Rotating moves every element the same way, but the element pushed off one end wraps around to the empty spot at the other end. Nothing is lost.

start:          10  20  30  40  50
shift left:     20  30  40  50   0     (10 is lost; 0 fills the end)
rotate left:    20  30  40  50  10     (10 wraps to the end)
shift right:     0  10  20  30  40     (50 is lost; 0 fills the front)
rotate right:   50  10  20  30  40     (50 wraps to the front)

The tool is the assignment line[i] = line[i + 1];, which copies the element at index i + 1 into index i. Each copy overwrites what was there, so two questions decide whether the algorithm works: in which order are the copies made, and is the overwritten value still needed?

int[] line = {10, 20, 30, 40, 50};
for (int i = 0; i < line.length - 1; i++)
{
    line[i] = line[i + 1];
}
line[line.length - 1] = 0;
for (int value : line)
{
    System.out.print(value + " ");
}
System.out.println();

20 30 40 50 0

To rotate, keep the element that falls off before the loop overwrites it, then put it in the empty spot afterward. Rotating to the right also changes the direction of the loop, for a reason the Watch Out below makes clear.

int[] line = {10, 20, 30, 40, 50};
int last = line[line.length - 1];
for (int i = line.length - 1; i > 0; i--)
{
    line[i] = line[i - 1];
}
line[0] = last;
for (int value : line)
{
    System.out.print(value + " ");
}
System.out.println();

50 10 20 30 40

int[] line = {10, 20, 30, 40, 50};
for (int i = 0; i < line.length - 1; i++)
{
    line[i + 1] = line[i];
}
line[0] = 0;
for (int value : line)
{
    System.out.print(value + " ");
}
System.out.println();

0 10 10 10 10

int[] queue = {3, 6, 9, 12};
int first = queue[0];
for (int i = 0; i < queue.length - 1; i++)
{
    queue[i] = queue[i + 1];
}
queue[queue.length - 1] = first;
for (int value : queue)
{
    System.out.print(value + " ");
}
System.out.println();

int[] line = {10, 20, 30, 40, 50};
for (int i = 0; i < line.length - 1; i++)
{
    line[i] = line[i + 1];
}
line[line.length - 1] = line[0];
for (int value : line)
{
    System.out.print(value + " ");
}
System.out.println();

A race app lists runners from first place to last, but the award ceremony calls them from last to first. To reverse an array is to put its elements in the opposite order: the first becomes the last, the second becomes the second-to-last, and so on.

Each element trades places with its mirror: the element the same distance from the other end. For an array of length n, the mirror of index i is index n - 1 - i. Index 0 pairs with index n − 1, index 1 with index n − 2, and so on toward the middle.

Trading two elements needs care. If you write a[i] = a[mirror]; first, the old a[i] is overwritten and gone. So a swap uses a third variable: copy one value into temp, overwrite that spot with the other value, then put temp into the second spot. It is like swapping the contents of two full cups: you need an empty third cup.

int temp = values[i];
values[i] = values[mirror];
values[mirror] = temp;

String[] runners = {"Ava", "Ben", "Cal", "Dee", "Eli"};
for (int i = 0; i < runners.length / 2; i++)
{
    int mirror = runners.length - 1 - i;
    String temp = runners[i];
    runners[i] = runners[mirror];
    runners[mirror] = temp;
}
for (String name : runners)
{
    System.out.print(name + " ");
}
System.out.println();

Eli Dee Cal Ben Ava

Sometimes the original order must be kept. Then build a new array of the same length and fill it in reverse. No swap is needed, because nothing in the original is overwritten.

int[] nums = {1, 4, 9, 16};
int[] backward = new int[nums.length];
for (int i = 0; i < nums.length; i++)
{
    backward[nums.length - 1 - i] = nums[i];
}
for (int value : backward)
{
    System.out.print(value + " ");
}
System.out.println();
for (int value : nums)
{
    System.out.print(value + " ");
}
System.out.println();

16 9 4 1
1 4 9 16

int[] nums = {1, 4, 9, 16};
for (int i = 0; i < nums.length; i++)
{
    int mirror = nums.length - 1 - i;
    int temp = nums[i];
    nums[i] = nums[mirror];
    nums[mirror] = temp;
}
for (int value : nums)
{
    System.out.print(value + " ");
}
System.out.println();

1 4 9 16

int[] nums = {1, 2, 3, 4};
for (int i = 0; i < nums.length / 2; i++)
{
    int mirror = nums.length - 1 - i;
    nums[i] = nums[mirror];
    nums[mirror] = nums[i];
}
for (int value : nums)
{
    System.out.print(value + " ");
}
System.out.println();

int temp = nums[i];
nums[i] = nums[mirror];
nums[mirror] = temp;

for (/* header */)
{
    int mirror = nums.length - 1 - i;
    int temp = nums[i];
    nums[i] = nums[mirror];
    nums[mirror] = temp;
}

Real programs give each algorithm its own method, then call the methods on the same array. This program tracks one student’s six quiz scores, oldest first. Each method is one algorithm from this chapter, labeled with a comment. The methods are public static class methods (Topic 3.7), so main calls them by name.

public class QuizTracker
{
    // sum, then divide by the length
    public static double average(int[] scores)
    {
        int total = 0;
        for (int score : scores)
        {
            total += score;
        }
        return (double) total / scores.length;
    }

    // maximum: remember the index of the best so far
    public static int bestIndex(int[] scores)
    {
        int best = 0;
        for (int i = 1; i < scores.length; i++)
        {
            if (scores[i] > scores[best])
            {
                best = i;
            }
        }
        return best;
    }

    // count: how many scores are below the cutoff
    public static int countBelow(int[] scores, int cutoff)
    {
        int count = 0;
        for (int score : scores)
        {
            if (score < cutoff)
            {
                count++;
            }
        }
        return count;
    }

    // consecutive pairs: how many times a score beat the one before it
    public static int improvements(int[] scores)
    {
        int count = 0;
        for (int i = 0; i < scores.length - 1; i++)
        {
            if (scores[i + 1] > scores[i])
            {
                count++;
            }
        }
        return count;
    }

    // duplicates: does any score appear more than once?
    public static boolean hasRepeat(int[] scores)
    {
        for (int i = 0; i < scores.length; i++)
        {
            for (int j = i + 1; j < scores.length; j++)
            {
                if (scores[i] == scores[j])
                {
                    return true;
                }
            }
        }
        return false;
    }

    // reverse: swap each element in the first half with its mirror
    public static void reverse(int[] scores)
    {
        for (int i = 0; i < scores.length / 2; i++)
        {
            int mirror = scores.length - 1 - i;
            int temp = scores[i];
            scores[i] = scores[mirror];
            scores[mirror] = temp;
        }
    }

    public static void main(String[] args)
    {
        int[] quizzes = {78, 85, 85, 62, 90, 86};
        System.out.println("Average: " + average(quizzes));
        int best = bestIndex(quizzes);
        System.out.println("Best: quiz " + best + " with " + quizzes[best]);
        System.out.println("Below 80: " + countBelow(quizzes, 80));
        System.out.println("Improvements: " + improvements(quizzes));
        System.out.println("Repeat score: " + hasRepeat(quizzes));
        reverse(quizzes);
        System.out.print("Newest first: ");
        for (int score : quizzes)
        {
            System.out.print(score + " ");
        }
        System.out.println();
    }
}

Average: 81.0
Best: quiz 4 with 90
Below 80: 2
Improvements: 2
Repeat score: true
Newest first: 86 90 62 85 85 78

• Sums, averages, and counts use an accumulator that starts before the traversal and changes inside it. An array’s length gives the number of elements for an average, and a traversal must start at index 0 to include every element.
• A minimum or maximum starts its best so far at values[0]. Keeping the best index instead of the best value tells you both where the best element is and what it is; compare elements with elements, never with an index.
• “At least one” starts a flag at false and “all” starts it at true; in a method, a return inside the loop can end early, but only for the answer that one element can prove.
• Consecutive pairs use values[i] and values[i + 1] with i < values.length - 1. Duplicates need a nested loop with j starting at i + 1, so every pair of different indices is compared exactly once.
• Shifting and rotating copy each element into a neighbor’s spot, moving through the array opposite to the direction the elements travel; rotating saves the element that falls off first. Reversing swaps each element in the first half with its mirror, using a temporary variable, and stops at length / 2.

public class MysteryIncreasing
{
    public static boolean mystery(int[] values)
    {
        for (int i = 1; i < values.length; i++)
        {
            if (values[i] <= values[i - 1])
            {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args)
    {
        int[] a = {2, 5, 8, 9};
        int[] b = {2, 5, 5, 9};
        int[] c = {1, 5, 3};
        int[] d = {3, 1, 2};
        System.out.println(mystery(a));
        System.out.println(mystery(b));
        System.out.println(mystery(c));
        System.out.println(mystery(d));
    }
}

int[] seats = {5, 8, 1, 6};
int[] moved = new int[seats.length];
for (int i = 0; i < seats.length; i++)
{
    moved[(i + 1) % seats.length] = seats[i];
}
for (int value : moved)
{
    System.out.print(value + " ");
}
System.out.println();

int[] ids = {6, 2, 6};
boolean hasDuplicate = false;
for (int i = 0; i < ids.length; i++)
{
    for (int j = i + 1; j < ids.length - 1; j++)
    {
        if (ids[i] == ids[j])
        {
            hasDuplicate = true;
        }
    }
}
System.out.println(hasDuplicate);

for (int j = i + 1; j < ids.length; j++)

int[] heights = {3, 7, 4, 8, 8, 2, 5};
int peaks = 0;
for (int i = 1; i < heights.length - 1; i++)
{
    if (heights[i] > heights[i - 1] && heights[i] > heights[i + 1])
    {
        peaks++;
    }
}
System.out.println(peaks);

String[] names = {"Maya", "Leo", "Zoe", "Ana", "Kai"};
String pick = names[0];
for (int i = 1; i < names.length; i++)
{
    if (names[i].compareTo(pick) > 0)
    {
        pick = names[i];
    }
}
System.out.println(pick);

public class DropFirstTwice
{
    public static void dropFirst(int[] list)
    {
        for (int i = 0; i < list.length - 1; i++)
        {
            list[i] = list[i + 1];
        }
        list[list.length - 1] = 0;
    }

    public static void main(String[] args)
    {
        int[] orders = {4, 9, 2, 7};
        dropFirst(orders);
        dropFirst(orders);
        int total = 0;
        for (int order : orders)
        {
            System.out.print(order + " ");
            total += order;
        }
        System.out.println();
        System.out.println(total);
    }
}

2 7 0 0
9

double[] readings = {20.0, 22.5, 19.0, 26.5};
double sum = 0.0;
for (double r : readings)
{
    sum += r;
}
double average = sum / readings.length;
boolean allClose = true;
for (double r : readings)
{
    if (Math.abs(r - average) > 4.0)
    {
        allClose = false;
    }
}
System.out.println(average);
System.out.println(allClose);

• I can trace the sum and average of an array and explain why the traversal starts at index 0. Reread
• I can find the minimum or maximum of an array, and its index, without mixing up indices and elements. Reread
• I can count the elements that have a property, including at the boundary value. Reread
• I can decide whether at least one element or every element has a property, and explain where each return belongs. Reread
• I can visit every consecutive pair without going past the end of the array. Reread
• I can explain why the duplicate check uses a nested loop with j starting at i + 1. Reread
• I can predict the result of shifting or rotating an array left or right. Reread
• I can reverse an array with swaps and explain why the loop stops halfway. Reread
• I can trace a program that runs several array algorithms on the same array. Reread