Implementing 2D Array Algorithms

A teacher keeps quiz scores in a 2D array: one row per student, one column per quiz. At the end of the unit she wants the class’s total points and the average score on a quiz. In Topic 4.5 you added up a 1D array with one loop and a running total. In Topic 4.12 you learned to visit every element of a 2D array with nested loops. This topic puts the two together: every algorithm you used on a 1D array has a 2D version, and the main new decision is which elements the loops visit.

The plan in plain words: start a total at 0, visit every element in row-major order, and add each one to the total. The total is an accumulator, a variable that collects a result a little at a time across the passes of a loop (Topic 2.9). For the average, divide the total by the number of elements. A rectangular 2D array has grid.length rows with grid[0].length elements in each, so it holds grid.length * grid[0].length elements in all.

int[][] scores = { {8, 10, 7, 9},
                   {6, 9, 10, 8},
                   {10, 7, 7, 5} };
int total = 0;
for (int r = 0; r < scores.length; r++)
{
    for (int c = 0; c < scores[0].length; c++)
    {
        total += scores[r][c];
    }
}
int count = scores.length * scores[0].length;
double average = (double) total / count;
System.out.println("Total: " + total);
System.out.println("Average: " + average);

Total: 96
Average: 8.0

Because the algorithm visits every element and the order of adding does not change a sum, nested enhanced for loops from Topic 4.12 work just as well. Here the data change too: two rows of three practice times, in minutes.

int[][] minutes = { {10, 5, 8},
                    {7, 9, 6} };
int total = 0;
for (int[] row : minutes)
{
    for (int value : row)
    {
        total += value;
    }
}
int count = minutes.length * minutes[0].length;
double average = (double) total / count;
System.out.println("Total: " + total);
System.out.println("Average: " + average);

The outer variable row is a whole int[] row, and the inner variable value is one int from that row. The six values add to 45, there are 2 × 3 = 6 of them, and (double) 45 / 6 is 7.5. The output is Total: 45 and then Average: 7.5. Use enhanced loops when you need every value but not its position; use index loops when you need r or c (you will need them soon).

int[][] minutes = { {10, 5, 8},
                    {7, 9, 6} };
int total = 0;
for (int[] row : minutes)
{
    for (int value : row)
    {
        total += value;
    }
}
int count = minutes.length * minutes[0].length;
double average = total / count;
System.out.println("Average: " + average);

int[][] grid = { {3, -2},
                 {5, 1},
                 {4, 7} };
int sum = 0;
for (int[] row : grid)
{
    for (int value : row)
    {
        sum += value;
    }
}
System.out.println(sum);
System.out.println((double) sum / (grid.length * grid[0].length));

18
3.0

The teacher now asks smaller questions. What is one student’s total? What was the class average on one quiz? Those answers come from a single row or a single column, not from the whole array. Visiting everything and then picking out the right values would work, but there is a simpler idea.

Fix one index and loop the other. Every element of row 1 has a first index of 1, so a loop that keeps the row at 1 and lets the column run from 0 to the end visits exactly row 1. Every element of column 2 has a second index of 2, so a loop that keeps the column at 2 and lets the row run visits exactly column 2. Either way you need one loop, not two.

The bound matters. A row has as many elements as there are columns, so a row loop stops at grid[row].length. A column has as many elements as there are rows, so a column loop stops at grid.length.

int[][] scores = { {8, 10, 7, 9},
                   {6, 9, 10, 8},
                   {10, 7, 7, 5} };
int student = 1;
int rowTotal = 0;
for (int c = 0; c < scores[student].length; c++)
{
    rowTotal += scores[student][c];
}
System.out.println("Student 1 total: " + rowTotal);

int quiz = 2;
int colTotal = 0;
for (int r = 0; r < scores.length; r++)
{
    colTotal += scores[r][quiz];
}
double quizAverage = (double) colTotal / scores.length;
System.out.println("Quiz 2 average: " + quizAverage);

Student 1 total: 33
Quiz 2 average: 8.0

A region does not have to be a whole row or column. Any rectangle works: choose where each loop starts and where it stops. Here the teacher wants the points from the second half of the unit, quizzes 2 and 3, for every student. The row loop still covers all rows; the column loop starts at 2 instead of 0.

int[][] scores = { {8, 10, 7, 9},
                   {6, 9, 10, 8},
                   {10, 7, 7, 5} };
int secondHalf = 0;
for (int r = 0; r < scores.length; r++)
{
    for (int c = 2; c < scores[0].length; c++)
    {
        secondHalf += scores[r][c];
    }
}
System.out.println("Quizzes 2 and 3 total: " + secondHalf);

The elements visited are 7 and 9 from row 0, 10 and 8 from row 1, and 7 and 5 from row 2. They add to 46, so the output is Quizzes 2 and 3 total: 46. Changing a loop’s starting value or its bound is how you aim an algorithm at any rectangular part of the array.

int[][] scores = { {8, 10, 7, 9},
                   {6, 9, 10, 8},
                   {10, 7, 7, 5} };
int quiz = 2;
int colTotal = 0;
for (int r = 0; r < scores[0].length; r++)
{
    colTotal += scores[r][quiz];
}
System.out.println("Quiz 2 total: " + colTotal);

java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3

int[][] grid = { {2, 4, 6},
                 {1, 3, 5},
                 {7, 8, 9} };
int down = 0;
for (int r = 0; r < grid.length; r++)
{
    down += grid[r][1];
}
int across = 0;
for (int c = 0; c < grid[2].length; c++)
{
    across += grid[2][c];
}
System.out.println(down);
System.out.println(across);

15
24

A weather app stores daily high temperatures: one row per city, one column per day. Which reading was the hottest, and in which city on which day? This is the maximum algorithm from Topic 4.5, with two changes: it visits a 2D region, and it remembers a row and a column for the location instead of a single index.

The plan: start with a “best so far” equal to an element that really is in the region, then compare every element with it and replace it whenever you find something better. Starting with a real element guarantees the answer is a value from the array.

int[][] temps = { {58, 61, 55, 60},
                  {52, 49, 57, 63},
                  {66, 59, 50, 62} };
int highest = temps[0][0];
int bestRow = 0;
int bestCol = 0;
for (int r = 0; r < temps.length; r++)
{
    for (int c = 0; c < temps[0].length; c++)
    {
        if (temps[r][c] > highest)
        {
            highest = temps[r][c];
            bestRow = r;
            bestCol = c;
        }
    }
}
System.out.println("Highest: " + highest);
System.out.println("City " + bestRow + ", day " + bestCol);

Highest: 66
City 2, day 0

Now vary the region and the direction: the coldest reading on day 2, which is column 2. The search starts at temps[0][2], the first element of that column, and flips > to <.

int[][] temps = { {58, 61, 55, 60},
                  {52, 49, 57, 63},
                  {66, 59, 50, 62} };
int day = 2;
int lowest = temps[0][day];
for (int r = 1; r < temps.length; r++)
{
    if (temps[r][day] < lowest)
    {
        lowest = temps[r][day];
    }
}
System.out.println("Lowest on day 2: " + lowest);

lowest starts at 55 (city 0). Because row 0 has already been used to start, the loop begins at r = 1. City 1 has 57, which is not smaller. City 2 has 50, which is, so lowest becomes 50. The output is Lowest on day 2: 50. Starting the loop at 1 or at 0 gives the same answer; starting at 1 just skips comparing the first element with itself.

int[][] winter = { {-5, -12, -3},
                   {-8, -1, -6} };
int highest = 0;
for (int[] row : winter)
{
    for (int temp : row)
    {
        if (temp > highest)
        {
            highest = temp;
        }
    }
}
System.out.println("Highest: " + highest);

int[][] prices = { {12, 15, 11, 14},
                   {7, 4, 9, 4} };
int store = 1;
int cheapest = prices[store][0];
int where = 0;
for (int c = 1; c < prices[store].length; c++)
{
    if (prices[store][c] < cheapest)
    {
        cheapest = prices[store][c];
        where = c;
    }
}
System.out.println(cheapest + " at " + where);

4 at 1

int[][] prices = { {12, 15, 11, 14},
                   {7, 4, 9, 4} };
int cheapest = 0;
for (int[] row : prices)
{
    for (int price : row)
    {
        if (price < cheapest)
        {
            cheapest = price;
        }
    }
}
System.out.println(cheapest);

A theater stores its seating chart as a 2D array of names, with "empty" for an unsold seat. Is there at least one empty seat? Did every student score at least 7 on a quiz? Each question has a yes-or-no answer about many elements at once, and the program can only be sure after it has looked at all of them.

You met the tool for this in Topic 4.5 (and Topic 2.10): a flag, a boolean variable that starts with one value before the loop and is switched to the other value inside the loop when something you are watching for happens. In a 2D array the flag works the same way; it just sits outside both loops.

String[][] seats = { {"Ana", "Raj", "Lee"},
                     {"Mo", "empty", "Kai"},
                     {"Sam", "Eve", "Zoe"} };
boolean anyEmpty = false;
for (String[] row : seats)
{
    for (String name : row)
    {
        if (name.equals("empty"))
        {
            anyEmpty = true;
        }
    }
}
System.out.println("Any empty seat: " + anyEmpty);

Any empty seat: true

Now ask the “all” question about one column: did every student score at least 7 on quiz 3? The flag starts true (“no failure seen yet”) and switches to false the moment one score is below 7. Because it is one column, a single loop over the rows is enough, as in 4.13.2.

int[][] scores = { {8, 10, 7, 9},
                   {6, 9, 10, 8},
                   {10, 7, 7, 5} };
int quiz = 3;
boolean allPassed = true;
for (int r = 0; r < scores.length; r++)
{
    if (scores[r][quiz] < 7)
    {
        allPassed = false;
    }
}
System.out.println("Everyone passed quiz 3: " + allPassed);

Column 3 holds 9, 8, and 5. The 9 and 8 leave the flag alone; at 5, 5 < 7 is true and allPassed becomes false. The output is Everyone passed quiz 3: false. With quiz = 1, the column holds 10, 9, and 7; no score is below 7, the flag is never switched, and the answer would be true.

String[][] seats = { {"Ana", "Raj", "Lee"},
                     {"Mo", "empty", "Kai"},
                     {"Sam", "Eve", "Zoe"} };
boolean anyEmpty = false;
for (int r = 0; r < seats.length; r++)
{
    anyEmpty = false;
    for (int c = 0; c < seats[r].length; c++)
    {
        if (seats[r][c].equals("empty"))
        {
            anyEmpty = true;
        }
    }
}
System.out.println("Any empty seat: " + anyEmpty);

int[][] grid = { {4, 7, 2},
                 {6, 8, 10},
                 {3, 12, 5} };
boolean rowCheck = true;
for (int c = 0; c < grid[1].length; c++)
{
    if (grid[1][c] % 2 != 0)
    {
        rowCheck = false;
    }
}
boolean colCheck = true;
for (int r = 0; r < grid.length; r++)
{
    if (grid[r][0] % 2 != 0)
    {
        colCheck = false;
    }
}
System.out.println(rowCheck + " " + colCheck);

true false

A flag tells you whether something happens. Often you need how many: how many days it rained each week, or how many X’s sit on a diagonal of a game board. The counter from Topic 4.5 answers that: an int set to 0, increased by 1 each time an element meets the condition, and read after the loop.

In a 2D array, where you set the counter to 0 decides what it counts. Declared before both loops, it counts across the whole array. Declared at the top of the outer loop, it starts over for each row, so you get one count per row.

int[][] rain = { {0, 3, 0, 0, 5},
                 {2, 4, 1, 0, 0},
                 {0, 0, 0, 0, 0} };
int total = 0;
for (int r = 0; r < rain.length; r++)
{
    int rainyDays = 0;
    for (int c = 0; c < rain[r].length; c++)
    {
        if (rain[r][c] > 0)
        {
            rainyDays++;
        }
    }
    System.out.println("Week " + r + ": " + rainyDays);
    total += rainyDays;
}
System.out.println("Total rainy days: " + total);

Week 0: 2
Week 1: 3
Week 2: 0
Total rainy days: 5

Some regions are not rectangles. In a square 2D array (same number of rows and columns), the main diagonal is the line of elements from the top-left corner to the bottom-right corner: board[0][0], board[1][1], board[2][2], and so on. Their row and column indices are equal, so a single loop variable i can serve as both.

String[][] board = { {"X", "O", "X"},
                     {"O", "X", "O"},
                     {"O", "X", "O"} };
int xCount = 0;
for (int i = 0; i < board.length; i++)
{
    if (board[i][i].equals("X"))
    {
        xCount++;
    }
}
System.out.println("X on the diagonal: " + xCount);

X | O | X
O | X | O
O | X | O

The loop checks board[0][0] (X), board[1][1] (X), and board[2][2] (O), so the output is X on the diagonal: 2. The other diagonal, from top-right to bottom-left, keeps the row index rising while the column index falls: its elements are board[i][board.length - 1 - i], which are board[0][2], board[1][1], and board[2][0]. That diagonal holds X, X, and O, so it also has 2 X’s.

String[][] board = { {"X", "O", "X"},
                     {"O", "X", "O"},
                     {"O", "X", "O"} };
int xCount = 0;
for (int i = 0; i < board.length; i++)
{
    if (board[i][board.length - i].equals("X"))
    {
        xCount++;
    }
}
System.out.println("X on the other diagonal: " + xCount);

int[][] marks = { {5, 2, 9},
                  {8, 6, 1},
                  {3, 7, 6} };
for (int c = 0; c < marks[0].length; c++)
{
    int big = 0;
    for (int r = 0; r < marks.length; r++)
    {
        if (marks[r][c] >= 6)
        {
            big++;
        }
    }
    System.out.print(big + " ");
}
System.out.println();

1 2 2

A fitness tracker stores each person’s daily step counts in a row. On how many days did a person walk more than the day before? Each answer compares an element with its neighbor, the element right next to it. Elements that sit side by side are consecutive, and checking each neighbor pair is the “consecutive pairs” algorithm from Topic 4.5.

In a row, the neighbor of grid[r][c] is grid[r][c + 1], one column to the right. In a column, the neighbor of grid[r][c] is grid[r + 1][c], one row down. Because each pair reaches one step ahead, the loop must stop one early: a row of 5 elements has only 4 pairs, starting at columns 0 through 3.

int[][] steps = { {4200, 5100, 4900, 6000, 6000},
                  {3000, 3500, 4100, 3900, 4500} };
int person = 0;
int increases = 0;
for (int c = 0; c < steps[person].length - 1; c++)
{
    System.out.println(steps[person][c] + " -> " + steps[person][c + 1]);
    if (steps[person][c + 1] > steps[person][c])
    {
        increases++;
    }
}
System.out.println("Increases: " + increases);

4200 -> 5100
5100 -> 4900
4900 -> 6000
6000 -> 6000
Increases: 2

Now turn the pairs sideways. In a tile-matching game, two equal tiles stacked one above the other form a match. Down column 1, the neighbor is one row down, so the loop runs over rows and stops at board.length - 1.

int[][] board = { {2, 5, 1},
                  {2, 3, 1},
                  {4, 3, 1},
                  {4, 3, 2} };
int col = 1;
int matches = 0;
for (int r = 0; r < board.length - 1; r++)
{
    if (board[r][col] == board[r + 1][col])
    {
        matches++;
    }
}
System.out.println("Matching pairs in column 1: " + matches);

Column 1 holds 5, 3, 3, 3 from top to bottom. The pairs are (5, 3), (3, 3), and (3, 3), so the output is Matching pairs in column 1: 2. With 4 rows the loop runs r = 0, 1, 2; the last pair uses rows 2 and 3, the bottom row.

int[][] steps = { {4200, 5100, 4900, 6000, 6000},
                  {3000, 3500, 4100, 3900, 4500} };
int person = 0;
int increases = 0;
for (int c = 0; c < steps[person].length; c++)
{
    System.out.println(steps[person][c] + " -> " + steps[person][c + 1]);
    if (steps[person][c + 1] > steps[person][c])
    {
        increases++;
    }
}
System.out.println("Increases: " + increases);

int[][] levels = { {10, 4},
                   {13, 9},
                   {11, 2},
                   {16, 8} };
for (int r = 0; r < levels.length - 1; r++)
{
    System.out.println(levels[r + 1][0] - levels[r][0]);
}

3
-2
5

On a bingo card, no number may appear twice in a row. A class code list must not repeat a code anywhere. These are duplicate checks: does any value appear more than once?

Topic 4.5 solved this for a 1D array by comparing every pair of positions. The outer index i picks one element; the inner index j starts at i + 1 and picks each element after it. Starting j at i + 1 does two jobs: no element is compared with itself, and no pair is checked twice. A row or a column of a 2D array is a line of elements just like a 1D array, so the same two loops work on it once one index is fixed.

int[][] card = { {3, 12, 7, 12},
                 {5, 9, 1, 14} };
int row = 0;
boolean hasDuplicate = false;
for (int i = 0; i < card[row].length; i++)
{
    for (int j = i + 1; j < card[row].length; j++)
    {
        if (card[row][i] == card[row][j])
        {
            hasDuplicate = true;
        }
    }
}
System.out.println("Row 0 has a duplicate: " + hasDuplicate);

Row 0 has a duplicate: true

Checking the whole 2D array is harder, because a repeated value can sit in two different rows. One clear way is to reuse what you know: copy every element into a 1D array in row-major order, then run the 1D duplicate check on that copy.

int[][] codes = { {41, 17, 30},
                  {26, 8, 17} };
int[] all = new int[codes.length * codes[0].length];
int k = 0;
for (int[] row : codes)
{
    for (int value : row)
    {
        all[k] = value;
        k++;
    }
}
boolean hasDuplicate = false;
for (int i = 0; i < all.length; i++)
{
    for (int j = i + 1; j < all.length; j++)
    {
        if (all[i] == all[j])
        {
            hasDuplicate = true;
        }
    }
}
System.out.println("Any duplicate: " + hasDuplicate);

Lines 3–12 build all, a 1D array with room for 2 × 3 = 6 values, and fill it with an index k that moves forward once per element: {41, 17, 30, 26, 8, 17}. Lines 13–23 are the 1D duplicate check. The 17 at index 1 matches the 17 at index 5, so the output is Any duplicate: true. Notice that a row-by-row check would have said “no duplicate” for each row: {41, 17, 30} and {26, 8, 17} have no repeats on their own. The region you check changes the answer.

int[][] card = { {3, 12, 7, 12},
                 {5, 9, 1, 14} };
int row = 1;
boolean hasDuplicate = false;
for (int i = 0; i < card[row].length; i++)
{
    for (int j = 0; j < card[row].length; j++)
    {
        if (card[row][i] == card[row][j])
        {
            hasDuplicate = true;
        }
    }
}
System.out.println("Row 1 has a duplicate: " + hasDuplicate);

String[][] shifts = { {"Ava", "Ben"},
                      {"Cal", "Ava"},
                      {"Ben", "Dee"},
                      {"Eli", "Ben"} };
int col = 1;
for (int i = 0; i < shifts.length; i++)
{
    for (int j = i + 1; j < shifts.length; j++)
    {
        if (shifts[i][col].equals(shifts[j][col]))
        {
            System.out.println("rows " + i + " and " + j);
        }
    }
}

rows 0 and 3

A scrolling sign moves its letters one spot to the left every second, and the letter that falls off the left edge reappears on the right. In a falling-blocks game, a column of blocks drops down one spot and an empty space (0) appears at the top. Both programs move every element of one row or column by one position.

Two words describe these moves:

The steps are the same as for a 1D array in Topic 4.5, applied to one fixed row or column:

1. If you are rotating, save the element that will be pushed off, because the first copy will overwrite it.
2. Copy each element into its neighbor’s spot, starting at the end the elements move toward, so that each element is read before it is overwritten.
3. Put the saved element (rotate) or the fill value (shift) into the spot left open.

String[][] sign = { {"S", "A", "L", "E", "!"},
                    {"O", "P", "E", "N", "?"} };
int row = 0;
String first = sign[row][0];
for (int c = 0; c < sign[row].length - 1; c++)
{
    sign[row][c] = sign[row][c + 1];
}
sign[row][sign[row].length - 1] = first;
for (String letter : sign[row])
{
    System.out.print(letter);
}
System.out.println();

ALE!S

Now move a column the other way and shift instead of rotate. The blocks in column 0 fall down one row. The new values arrive from above, so the copying starts at the bottom and works up; the top spot becomes 0.

int[][] grid = { {7, 1, 4},
                 {2, 8, 5},
                 {9, 3, 6} };
int col = 0;
for (int r = grid.length - 1; r > 0; r--)
{
    grid[r][col] = grid[r - 1][col];
}
grid[0][col] = 0;
for (int[] row : grid)
{
    for (int value : row)
    {
        System.out.print(value + " ");
    }
    System.out.println();
}

Column 0 starts as 7, 2, 9 from top to bottom. When r is 2, grid[2][0] gets the 2 from above; when r is 1, grid[1][0] gets the 7 from above. The loop stops at r > 0, because the top row has nothing above it. Line 9 puts 0 in the top spot. The 9 that was at the bottom is gone, which is what makes this a shift and not a rotate.

0 1 4
7 8 5
2 3 6

String[][] sign = { {"S", "A", "L", "E", "!"},
                    {"O", "P", "E", "N", "?"} };
int row = 0;
int len = sign[row].length;
String last = sign[row][len - 1];
for (int c = 1; c < len; c++)
{
    sign[row][c] = sign[row][c - 1];
}
sign[row][0] = last;
for (String letter : sign[row])
{
    System.out.print(letter);
}
System.out.println();

int[][] grid = { {1, 5},
                 {2, 6},
                 {3, 7},
                 {4, 8} };
int col = 1;
int top = grid[0][col];
for (int r = 0; r < grid.length - 1; r++)
{
    grid[r][col] = grid[r + 1][col];
}
grid[grid.length - 1][col] = top;
for (int r = 0; r < grid.length; r++)
{
    System.out.println(grid[r][0] + " " + grid[r][1]);
}

1 6
2 7
3 8
4 5

int[][] lights = { {0, 0, 0, 0},
                   {6, 2, 8, 3} };
for (int c = 0; c < lights[1].length - 1; c++)
{
    lights[1][c] = lights[1][c + 1];
}
lights[1][lights[1].length - 1] = 0;
for (int value : lights[1])
{
    System.out.print(value + " ");
}
System.out.println();

A relay coach wants to run a team’s order backward, last runner first. That is a reversal: the first element trades places with the last, the second with the second-to-last, and so on, until the two ends meet in the middle.

Each trade is a swap, from Topic 4.5: save one value in a temporary variable, copy the other value over it, then put the saved value in the second spot. Without the temporary variable, the first copy would destroy one of the two values.

The partner of position c in a line of len elements is position len - 1 - c: 0 pairs with len - 1, 1 pairs with len - 2, and so on. Only the first half of the positions start a swap, so the loop runs while c < len / 2. With an odd length, integer division rounds down and the middle element stays where it is, which is exactly right.

int[][] lineup = { {4, 9, 2, 7, 5},
                   {1, 6, 3, 8, 0} };
int row = 0;
int len = lineup[row].length;
for (int c = 0; c < len / 2; c++)
{
    int temp = lineup[row][c];
    lineup[row][c] = lineup[row][len - 1 - c];
    lineup[row][len - 1 - c] = temp;
}
for (int value : lineup[row])
{
    System.out.print(value + " ");
}
System.out.println();

5 7 2 9 4

A column works the same way, with the loop running over rows. Here column 1 of a 4-row array is reversed, so len is grid.length and the loop index goes in the row position.

int[][] grid = { {1, 10},
                 {2, 20},
                 {3, 30},
                 {4, 40} };
int col = 1;
int len = grid.length;
for (int r = 0; r < len / 2; r++)
{
    int temp = grid[r][col];
    grid[r][col] = grid[len - 1 - r][col];
    grid[len - 1 - r][col] = temp;
}
for (int r = 0; r < len; r++)
{
    System.out.println(grid[r][0] + " " + grid[r][1]);
}

With 4 rows, len / 2 is 2, so there are two swaps: rows 0 and 3 trade 10 and 40, then rows 1 and 2 trade 20 and 30. An even length has no middle element; every element moves. Column 0 is unchanged.

1 40
2 30
3 20
4 10

int[][] lineup = { {4, 9, 2, 7, 5},
                   {1, 6, 3, 8, 0} };
int row = 0;
int len = lineup[row].length;
for (int c = 0; c < len; c++)
{
    int temp = lineup[row][c];
    lineup[row][c] = lineup[row][len - 1 - c];
    lineup[row][len - 1 - c] = temp;
}
for (int value : lineup[row])
{
    System.out.print(value + " ");
}
System.out.println();

String[][] team = { {"P", "Q", "R"},
                    {"S", "T", "U"},
                    {"V", "W", "X"} };
int col = 2;
int len = team.length;
for (int r = 0; r < len / 2; r++)
{
    String temp = team[r][col];
    team[r][col] = team[len - 1 - r][col];
    team[len - 1 - r][col] = temp;
}
for (String[] row : team)
{
    for (String name : row)
    {
        System.out.print(name);
    }
    System.out.println();
}

PQX
STU
VWR

int[][] lineup = { {4, 9, 2, 7, 5},
                   {1, 6, 3, 8, 0} };
int row = 0;
int len = lineup[row].length;
for (int c = 0; c < len / 2; c++)
{
    lineup[row][c] = lineup[row][len - 1 - c];
    lineup[row][len - 1 - c] = lineup[row][c];
}
for (int value : lineup[row])
{
    System.out.print(value + " ");
}
System.out.println();

int temp = lineup[row][c];
lineup[row][c] = lineup[row][len - 1 - c];
lineup[row][len - 1 - c] = temp;

A snack bar records daily sales in a 2D array: one row per week, one column per weekday, Monday (column 0) through Friday (column 4). The manager wants three answers: which week sold the most, whether Friday beat Thursday every single week, and how many days sold more than 20 items. The program below answers all three, and it puts the row total in its own method (Topic 3.5) so the “best week” search can call it.

public class SnackSales
{
    public static int rowTotal(int[][] grid, int row)
    {
        int total = 0;
        for (int c = 0; c < grid[row].length; c++)
        {
            total += grid[row][c];
        }
        return total;
    }

    public static void main(String[] args)
    {
        // rows are weeks; columns are Monday through Friday
        int[][] sales = { {12, 15, 9, 20, 31},
                          {14, 11, 18, 22, 27},
                          {10, 16, 13, 25, 35} };

        int bestWeek = 0;
        int bestTotal = rowTotal(sales, 0);
        for (int r = 1; r < sales.length; r++)
        {
            int total = rowTotal(sales, r);
            if (total > bestTotal)
            {
                bestTotal = total;
                bestWeek = r;
            }
        }
        System.out.println("Best week: " + bestWeek + " with " + bestTotal);

        int thursday = 3;
        boolean fridayAlwaysUp = true;
        for (int r = 0; r < sales.length; r++)
        {
            if (sales[r][thursday + 1] <= sales[r][thursday])
            {
                fridayAlwaysUp = false;
            }
        }
        System.out.println("Friday beat Thursday every week: " + fridayAlwaysUp);

        int busyDays = 0;
        for (int[] week : sales)
        {
            for (int amount : week)
            {
                if (amount > 20)
                {
                    busyDays++;
                }
            }
        }
        System.out.println("Days over 20: " + busyDays);
    }
}

Lines 3–11: a row total as a method. rowTotal is the one-row algorithm from 4.13.2: the row stays fixed and c runs across it. It receives a reference to the array (Topic 3.6) and a row number, and returns that row’s sum. It is static so main can call it without an object (Topic 3.7).

Lines 20–31: the best week. This is the maximum algorithm from 4.13.3, but the values being compared are row totals, not single elements. bestTotal starts at a real total, week 0’s, and the loop starts at week 1.

Lines 33–42: Friday versus Thursday. This is an “all” flag from 4.13.4 applied to a neighbor pair from 4.13.6: in each row it compares column 3 with column 4. The flag switches to false only if Friday is not greater. The pairs are 20 and 31, 22 and 27, 25 and 35; Friday wins all three, so the flag stays true.

Lines 44–55: busy days. A counter from 4.13.5 over the whole array with enhanced loops, since positions do not matter here. The values over 20 are 31, 22, 27, 25, and 35, so busyDays is 5. (The 20 in week 0 does not count; 20 > 20 is false.)

Best week: 2 with 99
Friday beat Thursday every week: true
Days over 20: 5

Every part of the program comes down to the same two decisions you made throughout this chapter: which elements to visit (all, one row, one column, or a pair of columns) and what to do with each one (add it, compare it with a best-so-far, switch a flag, or count it).

• A 2D algorithm makes two choices: which elements to visit and what to do with each. The 1D algorithms from Topic 4.5 supply the “what”; the loops supply the “which.”
• The whole array needs nested loops. One row keeps the row index fixed and loops the column up to the row’s length; one column keeps the column index fixed and loops the row up to grid.length. Changing a loop’s start or bound aims the algorithm at any rectangle, and [i][i] reaches the main diagonal of a square array.
• Totals start at 0, and an average casts to double before dividing. A minimum or maximum starts at an element of the region being searched, never at 0, and can store r and c to remember where the best value was.
• A flag answers “at least one?” (start false) or “all?” (start true) and is never switched back; a counter answers “how many?”. Where you set either one to its starting value decides whether you get one answer for the whole array or one per row.
• Neighbor pairs stop one early. Duplicate checks compare each position with every later one (j starts at i + 1). Shifting and rotating start copying at the end the values move toward; reversing swaps with a temporary variable for only the first half of the positions.

int[][] grid = { {4, 1, 6},
                 {2, 8, 3},
                 {5, 0, 7} };
int bestCol = 0;
int bestSum = Integer.MIN_VALUE;
for (int c = 0; c < grid[0].length; c++)
{
    int sum = 0;
    for (int r = 0; r < grid.length; r++)
    {
        sum += grid[r][c];
    }
    System.out.println("Column " + c + ": " + sum);
    if (sum > bestSum)
    {
        bestSum = sum;
        bestCol = c;
    }
}
System.out.println("Largest: column " + bestCol);

Column 0: 11
Column 1: 9
Column 2: 16
Largest: column 2

int[][] grid = { {3, -1, 4},
                 {5, 9, 2},
                 {-6, 5, -3} };
int count = 0;
for (int r = 0; r < grid.length; r++)
{
    boolean found = false;
    for (int c = 0; c < grid[r].length; c++)
    {
        if (grid[r][c] < 0)
        {
            found = true;
        }
    }
    if (found)
    {
        count++;
    }
}
System.out.println(count);

int[][] grid = { {50, 3, 8},
                 {6, 12, 4},
                 {9, 7, 1} };
int col = 1;
int largest = grid[0][0];
for (int r = 0; r < grid.length; r++)
{
    if (grid[r][col] > largest)
    {
        largest = grid[r][col];
    }
}
System.out.println(largest);

int largest = grid[0][col];

int[][] grid = { {1, 2, 3},
                 {4, 5, 6},
                 {7, 8, 9} };
int first = grid[1][0];
for (int c = 0; c < grid[1].length - 1; c++)
{
    grid[1][c] = grid[1][c + 1];
}
grid[1][grid[1].length - 1] = first;

int len = grid.length;
for (int r = 0; r < len / 2; r++)
{
    int temp = grid[r][2];
    grid[r][2] = grid[len - 1 - r][2];
    grid[len - 1 - r][2] = temp;
}
for (int[] row : grid)
{
    for (int value : row)
    {
        System.out.print(value + " ");
    }
    System.out.println();
}

1 2 9
5 6 4
7 8 3

// I
for (int r = 0; r < grid.length / 2; r++)
{
    int temp = grid[r][col];
    grid[r][col] = grid[grid.length - 1 - r][col];
    grid[grid.length - 1 - r][col] = temp;
}

// II
int[] copy = new int[grid.length];
for (int r = 0; r < grid.length; r++)
{
    copy[r] = grid[grid.length - 1 - r][col];
}
for (int r = 0; r < grid.length; r++)
{
    grid[r][col] = copy[r];
}

// III
for (int r = 0; r < grid.length; r++)
{
    int temp = grid[r][col];
    grid[r][col] = grid[grid.length - 1 - r][col];
    grid[grid.length - 1 - r][col] = temp;
}

boolean inOrder = true;
for (int r = 0; r < grid.length; r++)
{
    for (int c = 0; c < grid[r].length - 1; c++)
    {
        if (grid[r][c] > grid[r][c + 1])
        {
            inOrder = false;
        }
    }
}

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can total and average every element of a 2D array without losing the fraction. Reread
• I can aim an algorithm at one row, one column, or a rectangle by choosing which index stays fixed and where each loop starts and stops. Reread
• I can find a minimum or maximum in any region, start it at the right element, and remember its row and column. Reread
• I can use a flag to decide whether at least one element, or every element, in a region has a property. Reread
• I can count matching elements for the whole array, for each row, or along a diagonal. Reread
• I can visit every neighbor pair across a row or down a column without going out of bounds. Reread
• I can check a row, a column, or a whole 2D array for a repeated value. Reread
• I can shift or rotate a row or column and choose the direction to copy so nothing is overwritten too early. Reread
• I can reverse a row or column with swaps and explain why the loop stops halfway. Reread