8.1: Declaring + Initializing 2D Arrays; Determining their

Review: Arrays are a collection (list) of elements (primitive or object reference type data)

So, a 2-Dimensional array is an array where the elements within that array are other arrays

2D arrays can be better at storing certain types of information

  • Especially if the data represents a space, with rows and columns

Seating chart:

. Column 1 Column 2 Column 3  
Row 1 Abby Ben Clara Principalida
Row 2 Ethan Frank   Flanklin
Row 3 Isabelle John Kim Leo

Note that this is a non-rectangular 2D array

  • Or if the data needs to be classified under categories
. Month 1 Month 2 Month 3
Winter December January February
Spring March April May
Summer June July August
Fall Summer October November

This is a rectangular 2D array. Non-rectangular 2D arrays are not a part of the CSA course

Declaring a 2D array

2D Arrays can be declared like this:

dataType[][] nameOfArray;

Initializing a 2D array

new dataType[r][c];

r: number of rows (number of arrays)
c: number of columns (length of each array)

public class Seasons {

    private String[][] Seasons = new String[2][3];

    // Or, if you already know what the elements should be:

    private String[][] Seasons2 = {
        {"December", "January", "February"},
        {"March", "April", "May"},
        {"June", "July", "August"},
        {"September", "October", "November"}
    };

}

Size of 2D Arrays

The size of the 2D array is classified by number of rows by number of columns

Number of rows can be found like this:

r = trimesterCourses.length

This would give the number of arrays within the 2D array, since each array is an element

For number of columns:

c = trimesterCourses[0].length

This finds the number of elements of the first array within the 2D array.

Accessing the Elements of a 2D Array

The elements of a 2D array can be accessed using index

Seasons[0][2]

Output: February

the value in the first bracket is the index of the rows, or which array we are accessing. In this case, the 0th index means we are accessing the first array

The value in the second bracket is the index within the array. So we are looking for the 2nd value within the first array.

To update the element of a 2D array, all you need to do is reference its location and change the value.

public class Seasons {

    private String[][] seasons = new String[2][3];

    private static String[][] seasons2 = {
        {"December", "January", "February"},
        {"March", "April", "May"},
        {"June", "July", "August"},
        {"September", "October", "November"}
    };

    public static void main(String[] args) {
        System.out.println(seasons2[0][2]);
        seasons2[0][2] = "Changed Value";  
        System.out.println(seasons2[0][2]);
    }
}

Seasons.main(null);

Notes on Common Mistakes

Here are some notes on common mistakes made in the context of the 2D arrays question. People around the country will definitely make all of these mistakes many times over, so let’s hope that none of those people are people at our school.

Array Errors

We just had a lesson on common Arrays errors, so rather than rephrase their work, give these mistakes another look.

There are some Array errors that are especially relevant to 2D arrays problems, however. For example…

  • Off-By-One Errors

When working with a 2D array, you are working with an array full of arrays. In this structure, there is a set number of rows and columns when the structure is initialized. The length of each row and the number of rows are often different, so both must be identified properly before iterating using index-based loops.

Out of bounds errors will always lose you at least one point on the scoring guidelines, according to our research.

  • For-Each loop modification

If values are intended to be modified during an iterative process, do not use a for-each loop. The elements accessed using this strategy are copies; accessing the array indexes directly to make modifications is the only way for them to be retained. See the example below:

import java.util.Arrays;

int[][] modifyArray = {
    {1, 4, 3},
    {3, 8, 9}
};

System.out.println("Prior to modification: " + Arrays.deepToString(modifyArray));

for (int[] row : modifyArray) {
    for (int col : row) {
        if (col == 3) {
            col = 0;
        }
    }
}

System.out.println("After to modification: " + Arrays.deepToString(modifyArray));

Prior to modification: [[1, 4, 3], [3, 8, 9]]
After to modification: [[1, 4, 3], [3, 8, 9]]

Instead, when modifying, you can use a traditional for loop (which also comes with the added benefit of having direct access to the relevant indexes):

import java.util.Arrays;

int[][] actualModifyArray = {
    {1, 4, 3},
    {3, 8, 9}
};

System.out.println("Prior to modification: " + Arrays.deepToString(actualModifyArray));

for (int r = 0; r < actualModifyArray.length; r++) {
    for (int c = 0; c < actualModifyArray[r].length; c++) {
        if (actualModifyArray[r][c] == 3) {
            actualModifyArray[r][c] = 0;
        }
    }
}

System.out.println("After to modification: " + Arrays.deepToString(actualModifyArray));

Prior to modification: [[1, 4, 3], [3, 8, 9]]
After to modification: [[1, 4, 0], [0, 8, 9]]

FRQ Scoring Guidelines Mistakes

To succeed on the AP test, it’s important to be able to identify which elements of a correct answer earn points.

  • Most often, if you create a method in a previous part used to interact with a 2D array, it is intended that you use that method again in future methods.

Means of traversing and interacting with 2D arrays are relatively specific in the context of one College Board problem (i.e., iterate through to determine a condition about a row, find a value in a row, search columns by condition, etc.), so make sure to analyze the context to determine if a certain method may be used again to abstract what would otherwise be a more complex task in a future method. With practice, this connection should be obvious.

If there is no possible relevance between two methods, this may not necessarily be the case.

Make sure that you use the proper parameters when calling your own method! Scoring guidelines are sometimes lenient about this, but don’t tempt fate. Just format your call properly.

  • If a “helper” method is provided to you in a question, make sure to note it and use it.

If one is provided, it is most certainly present to make the process of writing the code less complex. Scoring guidelines will always include utilizing past student-created methods and “helper” methods.

You can also use the helper method’s functionality to aid your thinking about a question. If you are confused by its content and aren’t sure how to tackle the problem instinctively, you can be sure that a provided “helper” method will be a part of the solution.

Once again, make sure that you’re using the proper parameters!

  • Know how to use column-major order. (Many go into the test having only used row-major order.)

It’s very possible that a question will prompt you to access a 2D array by its columns. (We found two in research for this lesson.) If you know you haven’t practiced column-major order, give the code below a look. It might be a good idea to create your own code cell with a unique 2D array to practice with.

int[][] array = {
    {3, 5, 1},
    {9, 9, 7}
};

// you should always be able to use array[0].length for the number of columns
// since each row is the same length
int colNum = 1;
for (int col = 0; col < array[0].length; col++) {
    System.out.print("Column " + colNum + ":\t");
    for (int row = 0; row < array.length; row++) {
        System.out.print(array[row][col] + "\t");
    }
    System.out.println();
    colNum++;
}

Column 1:	3	9	
Column 2:	5	9	
Column 3:	1	7

Popcorn Hack:

public class TrimesterGrades {

    private int[][] trimesterGrades = {
        {85, 90, 78, 92, 99}, // tri 1
        {92, 88, 91, 97, 80}, // tri 2
        {79, 85, 83, 95, 67}  // tri 3
    };

    public void print(){
        for (int i = 0; i < trimesterGrades.length; i++) {
            System.out.println("Trimester " + (i + 1) + ": " + Arrays.toString(trimesterGrades[i]));
        }
    }

    public void retakeExam(int tri, double newGrade) {
        int overallGrade = 0;
        int triIdx = tri - 1;
        int oldTest = trimesterGrades[triIdx][trimesterGrades[triIdx].length-1];
        for (int i = 0; i < trimesterGrades[triIdx].length; i++) {
            overallGrade += trimesterGrades[triIdx][i];
        }
        double maxGrade = trimesterGrades[triIdx].length * 100;
        double grade = overallGrade / maxGrade * 100;
        double gradeBeforeTest = 0;
        
        // finding the grade needed on the last test to raise the grade to a 90
        for (int i = 0; i < trimesterGrades[triIdx].length-1; i++) {
                gradeBeforeTest += trimesterGrades[triIdx][i];        
            }

        double gradeNeeded = (newGrade/100) * maxGrade - gradeBeforeTest;
        
        int replacedGrade = (int) gradeNeeded;
        trimesterGrades[triIdx][trimesterGrades[triIdx].length-1] = replacedGrade;
        
        System.out.println("Grade on Retake Test: " + trimesterGrades[triIdx][trimesterGrades[triIdx].length-1]);
        System.out.println("Old Grade on Test: " + oldTest);
        System.out.println("Grade Before Test: " + grade);
        System.out.println("Grade After Test: " + newGrade);
    }

    public static void main(String args[]) {
        TrimesterGrades grades = new TrimesterGrades();
        System.out.println("Before retake:");
        grades.print();
        System.out.println("");
        
        grades.retakeExam(3, 90);
        System.out.println("\nAfter retake:");
        grades.print();
    }

}

TrimesterGrades.main(null);

Before retake:
Trimester 1: [85, 90, 78, 92, 99]
Trimester 2: [92, 88, 91, 97, 80]
Trimester 3: [79, 85, 83, 95, 67]

Grade on Retake Test: 108
Old Grade on Test: 67
Grade Before Test: 81.8
Grade After Test: 90.0

After retake:
Trimester 1: [85, 90, 78, 92, 99]
Trimester 2: [92, 88, 91, 97, 80]
Trimester 3: [79, 85, 83, 95, 108]

The 2D array keeps track of a students grade, grouped by each trimester. The student, currently in Trimester 3, retook a test in their 3rd period, which raised that grade to 90.

Show how they would write code that changes the grade for the 3rd period class

Hacks: Finish FRQ from Friday, 2015 Q1 Part B & C

(Question indicated to perform 2019 Question 3 however those were not the questions as assigned on Friday the instructions were revised to remove the contradiction)

image

(b) Write a static method rowSums that calculates the sums of each of the rows in a given twodimensional array and returns these sums in a one-dimensional array. The method has one parameter, a twodimensional array arr2D of int values. The array is in row-major order: arr2D[r][c] is the entry at row r and column c. The method returns a one-dimensional array with one entry for each row of arr2D such that each entry is the sum of the corresponding row in arr2D. As a reminder, each row of a two-dimensional array is a one-dimensional array. For example, if mat1 is the array represented by the following table, the call rowSums(mat1) returns the array {16, 32, 28, 20}. Assume that arraySum works as specified, regardless of what you wrote in part (a). You must use arraySum appropriately to receive full credit. Complete method rowSums below.

// Part A as requested on Friday 
// Returns the sum of the entries in the one-dimensional array arr.
public static int arraySum(int[] arr){
    int sum = 0;
    for (int i = 0; i < arr.length; i++){
        sum += arr[i];
    }
    return sum;
} 

int[] arr = {1, 2, 3, 4, 5};

System.out.println(arraySum(arr)); // 15

15

/** Returns a one-dimensional array in which the entry at index k is the sum of * the entries of row k of the two-dimensional array arr2D. */ 
public static int[] rowSums(int[][] arr2D){
    int[] sums = new int[arr2D.length];
    for (int i = 0; i < arr2D.length; i++){
        sums[i] = arraySum(arr2D[i]);
    }

    return sums;
}

int[][] arr2D = {
    {1, 2, 3}, 
    {4, 5, 6}, 
    {7, 8, 9}
};

System.out.println(Arrays.toString(rowSums(arr2D))); // {6, 15, 24}

[6, 15, 24]

image

(c) A two-dimensional array is diverse if no two of its rows have entries that sum to the same value. In the following examples, the array mat1 is diverse because each row sum is different, but the array mat2 is not diverse because the first and last rows have the same sum.Assume that arraySum and rowSums work as specified, regardless of what you wrote in parts (a) and (b). You must use rowSums appropriately to receive full credit. Complete method isDiverse below.

public static boolean isDiverse(int[][] mat1){
    boolean diverse = false;
    int[] rowSums = rowSums(mat1);

    for(int i = 0; i < rowSums.length; i++){
        for(int j = i+1; j < rowSums.length; j++){
            if (rowSums[i] != rowSums[j]){
                continue;
            } else{
                return diverse;
            }
        }
    }
    diverse = true;
    return diverse;
}

int[][] mat1 = new int[][]{
    {1,3,2,7,3},
    {10,10,4,6,2},
    {5,3,5,9,6},
    {7,6,4,2,1}
};

System.out.println("Call 1 Mat 1");
System.out.println(isDiverse(mat1));

int[][] mat2 = {
    {1,1,5,3,4},
    {12,7,6,1,9},
    {8,11,10,2,5},
    {3,2,3,0,6}
};


System.out.println("\nCall 2 Mat 2");
System.out.println(isDiverse(mat2));

Call 1 Mat 1
true

Call 2 Mat 2
false