Lecture Notes 15: More About 2-D Arrays

Objectives

By the end of this module, you will:

Distinguish between the array and Cartesian views of a 2D array.
Identify the correct access method into a 2D array depending on the application.
Demonstrate the capacity to design an approach to solve common 2-D array manupulations.

Before Starting

Read Section 15.01 in the Codio Course

If you do not have your Codio course ready, use any text editor or simple IDE. Some possibilities are:

Write using Sublime; Compile and run in the Terminal
Use IDEs like: IntelliJ, DrJava, or JGrasp

Catching Up

Before we move forward, let's catch up (complete any remaining work from the previous module)
In this case, make sure we've got:

Two-Dimensional Arrays... Declaring, Initializing, and Accessing!

2D arrays: Array (table) vs. Cartesian (grid) view

There are two common ways of interpreting and visualizing a 2D array:

As an array with the first row on top, followed by the second row below it and so on.
As a grid that's aligned with the Cartesian x and y axes.

Let's expound with an example:

Consider this array of strings:

  String[][] A = {
      {"(0,0)", "(0,1)", "(0,2)", "(0,3)", "(0,4)"},
      {"(1,0)", "(1,1)", "(1,2)", "(1,3)", "(1,4)"},
      {"(2,0)", "(2,1)", "(2,2)", "(2,3)", "(2,4)"},
      {"(3,0)", "(3,1)", "(3,2)", "(3,3)", "(3,4)"},
  };

Here, we have deliberately put "coordinates" as strings in an array.

Observe that, as we look at the array, we can see that row 2 is below row 1:

  String[][] A = {
      {"(0,0)", "(0,1)", "(0,2)", "(0,3)", "(0,4)"},
      {"(1,0)", "(1,1)", "(1,2)", "(1,3)", "(1,4)"},
      {"(2,0)", "(2,1)", "(2,2)", "(2,3)", "(2,4)"},
      {"(3,0)", "(3,1)", "(3,2)", "(3,3)", "(3,4)"},
  };

and column 3 (fourth column) is exactly where we expect it to be:

  String[][] A = {
      {"(0,0)", "(0,1)", "(0,2)", "(0,3)", "(0,4)"},
      {"(1,0)", "(1,1)", "(1,2)", "(1,3)", "(1,4)"},
      {"(2,0)", "(2,1)", "(2,2)", "(2,3)", "(2,4)"},
      {"(3,0)", "(3,1)", "(3,2)", "(3,3)", "(3,4)"},
  };

Note: in both cases, we've boldfaced only the part of the string involved in the row or column number just to emphasize.

Of course, the whole string in each array element is the element. For example, the elements in column 3 are:

  String[][] A = {
      {"(0,0)", "(0,1)", "(0,2)", "(0,3)", "(0,4)"},
      {"(1,0)", "(1,1)", "(1,2)", "(1,3)", "(1,4)"},
      {"(2,0)", "(2,1)", "(2,2)", "(2,3)", "(2,4)"},
      {"(3,0)", "(3,1)", "(3,2)", "(3,3)", "(3,4)"},
  };

Now, when we print, we get the same view:

  // Normal array print:
  for (int i=0; i<A.length; i++) {
      for (int j=0; j<A[i].length; j++) {
          System.out.printf (" %6s", A[i][j]);
      }
      System.out.println ();
  }

Note: the format specifier of printf for strings is "s":
```
    System.out.printf (" %6s", A[i][j]);
     
```
(It was "d" for integers, "f" for double's).

Activity 1: Confirm this by writing up the above in MyArrayPrint.java.

Next, let's try this variation:

  // Cartesian print:
  for (int y=A[0].length-1; y>=0; y--) {
      for (int x=0; x<A.length; x++) {
          System.out.printf (" %6s", A[x][y]);
      }
      System.out.println ();
  }

Activity 2: Try the Cartesian printing approach in MyArrayPrint2.java.

What you should see:

  (0,4)  (1,4)  (2,4)  (3,4)
  (0,3)  (1,3)  (2,3)  (3,3)
  (0,2)  (1,2)  (2,2)  (3,2)
  (0,1)  (1,1)  (2,1)  (3,1)
  (0,0)  (1,0)  (2,0)  (3,0)

Pay attention to how the first coordinate is increasing in the bottom row:
```
  (0,4)  (1,4)  (2,4)  (3,4)
  (0,3)  (1,3)  (2,3)  (3,3)
  (0,2)  (1,2)  (2,2)  (3,2)
  (0,1)  (1,1)  (2,1)  (3,1)
  (0,0)  (1,0)  (2,0)  (3,0)
     
```
Here, the x-coordinate is increasing from 0, 1, 2, ... while the y-coordinate is 0.
Note that this is only a way to view the contents via printing. The actually array contents are unchanged.
In this view, we can treat the first dimension as the x-coordinate and the second as the y-coordinate, as Cartesian coordinates dictate.

Thus, when x=2 and y=3, the array element A[2][3] can be seen where we expect it in a Cartesian frame:

    |
    |  (0,4)  (1,4)  (2,4)  (3,4)
y=3 |  (0,3)  (1,3)  (2,3)  (3,3)
    |  (0,2)  (1,2)  (2,2)  (3,2)
    |  (0,1)  (1,1)  (2,1)  (3,1)
    |  (0,0)  (1,0)  (2,0)  (3,0)
  __|________________________________________
    |                 x=2

Why is this useful?
- When we work with actual Cartesian coordinates, it's useful to print in this fashion, and to track x,y in the familiar Cartesian way.

Designing Solutions that include 2-D Arrays

  public class GradingSpreadsheet {
      public static void main(String[] argv) {
          double[][] studentGrades = {{4, 3, 5, 2, 10},
                                      {8, 9, 9.5, 8, 0},
                                      {10, 10, 9, 9.5, 0}};
          String[] studentNames    = {"Larry", "Curly", "Moe"};

          // your code here!
      }
  }

A simple spreadsheet app -- you have an array of student grades (each row contains the grades for each homework), and the student names. You can see that Larry did something mischievous on the last assignment. Lets do some simple processing:

Activity 3: Add code to print each student's name, and their average grade over all homeworks.

Activity 4: Add code to print the average grade for each homework.

Activity 5: Create an array

double[] weights = {0.2, 0.1, 0.2, 0.3, 0.2};

with the same length as the number of homeworks. Compute a weighted grade, where the final grade for the student is determined by these weights on the homeworks. The formula for each final grade should be:

final = grade_0 * weight_0 + grade_1 * weight_1 + \dots + grade_{n-1} * weight__{n-1}

.

Activity 6: Add code to print, for each of the homeworks, the name of the student that got the highest grade.

Activity 7: Add code to print the standard deviation of the grades for each student. Remember:

\sigma_{student} = \sqrt{ \frac{\Sigma(x_i - \mu)^2}{N}}

. Activity 8: Add code to compute and print the grades "on a curve". How would you do this? Be creative; there are multiple ways

It's all better with methods! If we have the time, let's re-implement these as separate methods that each return the value, or list, as appropriate. Let''s use the file GradingSpreadsheetMethods.java for that purpose.

A Cool Game-Like application of 2-D Grids

Conways Game of Life is a simple cellular automaton, defined in Mathworld as: "A cellular automaton is a collection of "colored" cells on a grid of specified shape that evolves through a number of discrete time steps according to a set of rules based on the states of neighboring cells. The rules are then applied iteratively for as many time steps as desired"

Look at a visual repesentation of the rules

Look at this video: Epic GOL

Play with this GOL simulator

Check out XKCD's post in honor of John Conway