Here is a draft of solutions to Part 1 of the review questions.

_______________________________________________________________________________

1)  // return the Java equivalent of the Matlab expression $a(i,j)$
    static int[][] index(int[][] a, int[] i, int[] j) {
        // set b[row][col] to a[i[row]][j[col]] and return b
            int[][] b = new int[i.length][j.length];
            for (int row = 0; row<i.length; row++)
                for (int col = 0; col<j.length; col++)
                    b[row][col] = a[i[row]][j[col]];
            return b;
    }

    // return the indices $i$ where $b[i]$ is true 
    // (this is the Java equivalent of the Matlab expression $find(b)$ --
    // note that we neither taught nor expect(ed) you to use Matlab's FIND)
    static int[] find (boolean[] b) {
        int count = 0; // #positions so far in b[0..i-1] where b is true
        for (int i = 0; i<b.length; i++) if (b[i]) count++;
        int[] where = new int[count];
        int j = 0; // put next "true" position $i$ in $where[j]$
        for (int i = 0; i<b.length; i++) if (b[i]) { where[j] = i; j++; }
        return where;
    }

    // return the Java equivalent of the Matlab expression $a(i,j)$
    static int[][] index(int[][] a, boolean[] i, int[] j) {
        return index(a,find(i),j);
    }

    // return the Java equivalent of the Matlab expression $a(i,j)$
    static int[][] index(int[][] a, int[] i, boolean[] j) {
        return index(a,i,find(j));
    }

    // return the Java equivalent of the Matlab expression $a(i,j)$
    static int[][] index(int[][] a, boolean[] i, boolean[] j) {
        return index(a,find(i),find(j));
    }
_______________________________________________________________________________

2a) % set N to M with border deleted
        N = M(2:size(M,1)-1,2:size(M,2)-1);
 or % set N to M, then delete border of N
        N = M; 
        N([1 size(M,1)],:) = []; 
        N(:,[1 size(M,2)]) = []; 

2b) file count.m:
    _________________________________________________________________
    |                                                               |
    | function occur = count(v,x)                                   |
    | % OCCUR = COUNT(V,X):                                         |
    | % return number OCCUR of occurrences of scalar X in vector V  |
    |     occur = sum(v==x);                                        |
    |_______________________________________________________________|

2c) count(N(:,2), 99)
_______________________________________________________________________________

3)  See $decipher3.java$, posted separately.
_______________________________________________________________________________

4)  [Bonus-level question]

    Theorem: The best way to rearrange the contents of two equal-length
    row-vectors $x$ and $y$ to minimize the L1 distance between them is to sort
    each of them in non-ascending order.

(a) We may assume that $x$ is sorted: if $x$ is not sorted, then sort it using
    select sort, and each time two positions i&j in $x$ are swapped, then swap
    the same positions i&j in $y$.  This leaves the L1 distance 
    
        $|x[1]-y[1]| + |x[2]-y[2]| + ... + |x[n]-y[n]|$

    is unchanged because terms $|x[k]-y[k]|$ are unchanged for all positions
    $k$ different from $i$ and $j$, and terms $|x[i]-y[i]|$ and $|x[j]-y[j]|$
    are swapped.  Therefore, we are still add the same numbers, just in a
    slightly different order.

(b) Proof of the length=2 case.  

    Let $x1 >= x2$ be the values in $x$.
    Let $y1 >= y2$ be the values in $y$. 
    [y1,y2 are shorter names than ymax,min]

    Assume $x=[x1 x2]$ is sorted, as allowed by Part (a).

    Then $y=[y1 y2]$ is sorted with distance  $|x1-y1| + |x2-y2|$,
    and $y=[y2 y1]$ is unsorted with distance $|x1-y2| + |x2-y1|$.
    We wish to prove that the sorted distance is at most the unsorted distance.

    Let us proceed by case analysis on Cases 0-to-3.

    Case 0: y1 > x1
        
        Exchange $x$ and $y$ and continue with the appropriate case below.  
        
                                                
    Case 1:                x1  >=  y1  >=  y2  >=  x2
        
                           x1      y1      y2      x2
                 picture:  +-------+-------+-------+
            
          sorted distance: +-------+       +-------+   shorter by 2|y1-y2|
        
        unsorted distance: +-------+-------+
                                   +-------+-------+
        
    Case 2:                x1  >=  y1  >=  x2  >=  y2
        
                           x1      y1      x2      y2
                 picture:  +-------+-------+-------+
            
          sorted distance: +-------+       +-------+  shorter by 2|y1-x2|
        
        unsorted distance: +-------+-------+-------+
                                   +-------+
        
    Case 3:                x1  >=  x2  >=  y1  >=  y2
        
                           x1      x2      y1      y2
                 picture:  +-------+-------+-------+
            
          sorted distance: +-------+-------+          same distnce
                                   +-------+-------+
        
        unsorted distance: +-------+-------+-------+
                                   +-------+
        
(c) Part (a) allows us to assume $x$ is sorted.  

    Let $y$ be in any order.  Let $ys$ be $y$ in sorted order; note that $ys$
    is unique: there is only one sorted order.  Part (b) tells us that sorting
    $y$ by swapping elements that are out of order reduces the distance (or
    leaves it unchanged).  That is, the distance between $y$ and $x$ is greater
    or equal to the distance between $ys$ and $y$.

    Therefore, the minimum distance is achieved by $ys$, the sorted
    rearrangement of $y$.
_______________________________________________________________________________

5)  observe that the boundary of the triangle is a diagonal line.
    this has an equation of the form col = row + constant.
    we solve for $constant$ by looking at row = 1:
    the number of elements = min(width,height).
    therefore, the leftmost column at row=0 is at position 
    //                                ^^^^^ there was a typo, $1$ for $0$

    $col = width-min(width,height) = constant$.

    // return the sum of the largest possible upper right triangle 
    // in non-empty, row-major, rectangular array a
    int sumUpperTri(int[][] a) {
        int height = a.length, width = a[0].length; // dimensions of a
        // boundary of triangle is given by the equation: col = row + constant
            int constant = width - Math.min(width,height); 
            //                 ^^^^^ there was a typo: $=$ for $-$

        // set sum to elements in the triangle:
        // sum includes all appropriate elements from rows above row i, and
        // all appropriate elements in row i from columns to the left of col j
            int sum = 0;
            for (int i = 0; i<height; i++)
                for (int j = i +constant; j<a[i].length; j++) sum += a[i][j];

        return sum;
    }
_______________________________________________________________________________

6)  // check whether position r,c is within the boundaries of column-major $a$
    // and the value at that position is 1 higher than val
    public boolean CheckMove(int[][] a, int r, int c, int val) {
        return 0 <= c && c < a.length && 0<= r && r < a[c].length &&
                a[c][r] == val+1;
    }
_______________________________________________________________________________

7)  class Directory {
        private String[] last; // last names
        private String[] number; // phone number
        // create a directory with records (l[i], n[i]) of last names and #s
        Directory(String[] l, String[] n) { last = l; number = n; }
        // print records whose last name begins with prefix
        void query(String prefix) {
            // loop storyline: have processed records 0..i-1
            for (int i = 0; i<last.length; i++)
                if (last.startsWith(prefix)) 
                    System.out.println(last[i] +" "+ number[i]);
        }
    }

    On the final, we would remind/tell you of potentially relevant methods 
    in class String, like we did on Prelim 3.

or

    class Record { 
        String last, number; 
        Record(String l, String n) { last = l; number = n; }
    }

    class Directory {
        private Record[] record;
        // create a directory with records (l[i], n[i]) of last names and #s
        Directory(String[] l, String[] n) { 
            record = new Record[l.length];
            for (int i = 0; i<l.length; i++) record[i] = new Record(l[i],n[i]);
        }

        // create a directory with records r
        Directory(Record[] r) { record = r; }

        // print records whose last name begins with prefix
        void query(String prefix) {
            // loop storyline: have processed records 0..i-1
            for (int i = 0; i<last.length; i++)
                if (record[i].last.startsWith(prefix)) 
                    System.out.println(record[i].last +" "+ record[i].number);
        }
    }
_______________________________________________________________________________

8)  // sort parallel arrays name and age in increasing order of age
    // and break ties by alphabetical order of name
    static sort(String[] name, int[] age) {
        // name[0..i-1], age[0..i-1] are sorted
        for (int i = 0; i<name.length; i++) {
            int j = i; // position of smallest "unsorted" age&name in i..k-1
            for (int k = i+1; k<name.length; k++)
                if (age[k]<age[j] 
                      || age[k] == age[j] && name[k].compareTo(name[j])<0)
                    j = k;
            // swap entries at positions i and j
                String stmp = name[i]; name[i] = name[j]; name[j] = stmp;
                int itmp = age[i]; age[i] = age[j]; age[j] = itmp;
        }
    }
_______________________________________________________________________________

9)  how do we tell if we should print a number: 
    if the other array is empty 
       or it is smaller than the next number in the other array.

    // take two sorted (non-decreasing) arrays of integers;
    // print the numbers that are in either array but not the other.
    static void diffs(int[] a, int[] b) {
        int i = 0, j = 0; // a[0..i-1], b[0..j-1] have been processed
        while (i<a.length || j<b.length)
            if (i == a.length || b[j] < a[i]) 
                { System.out.println(b[j]); j++; }
            else if (j == b.length || a[i] < b[j])
                { System.out.println(a[]); i++; }
            else { i++; j++; }
    }
_______________________________________________________________________________

10) + A pair of integers is "good" if one or both integers is positive.
    + A pair of integers is "bad" if it is not "good".

// NOTE: originally posted solutions had guards for (a) and (b) swapped.

(a) Read integers and print the first bad pair of consecutive integers.

    TokenReader in = new TokenReader(System.in);
    int previous = in.readInt(); // previous input number
    int current  = in.readInt(); // current  input number
    while ( previous>0 || current>0 ) { // ! IS DISALLOWED
        previous = current;
        current = in.readInt();
    }
    System.out.println( previous + " " + current);

(b) To print the first good pair of consecutive integers, make the loop guard
    $previous<=0 && current<= 0$

_______________________________________________________________________________

11) // test p for primality

    TokenReader in = new TokenReader(System.in);
    int p = in.readInt();
    int d = 2;
    
    while ( p % d != 0)
        d = d+1 ;
    // typo fix: the $p == d$ and $p != d$ cases were switched
    if ( p == d )
        System.out.println( p + " is prime");
    else 
        System.out.println( p + " is not prime");
_______________________________________________________________________________

12) Two Persons *bilaterally* interact ("bilateral" means "something done in
    both directions") by having each Person *unilaterally* interact with the
    other ("unilateral" means "something done in only one direction").

    A *source* Person unilaterally interacts with a *target* Person as follows:
    + The source Person rolls his/her own die to obtain a number from 0 to
      his/her own $friendliness$ (inclusive).
    + If the die comes up 0, then the target Person becomes the latest enemy of
      the source Person, otherwise the source Person's enemy is  unchanged. 

(a) class Person {
        private String name;
        protected int friendliness;
        public Person enemy;
    
        // Constructor
        public Person(String n, int f) { 
            name = n; 
            friendliness = f; 
            enemy = null; // <-- oops, not specified in original question
        }
    
        // return description (name, friendliness, name of enemy)
        // (this is like method $describe$ on Prelim 2)
        public String toString() {
            String s = " no enemy";
            if (enemy != null) s = " enemy " + enemy.name;
            return name + " friendliness " + friendliness + s;
        }
    
        // bilaterally interact with Person p
        public void interact(Person p) {
            uniInteract(p);
            p.uniInteract(this);
        }
    
        // unilaterally interact with Person p
        public void uniInteract(Person p) {
            if (0 == (int)(Math.random()*(1+friendliness)))
                enemy = p;
        }
    }

(b)  class WackyPerson extends Person {
        // constructor: set name to n, friendliness to 2000, enemy to self
        WackyPerson(String n) {
            super(n,2000); // <-- MUST use $super$, since $name$ is $private$
            enemy = this;
        }
    
        // unilaterally interact: do 100 times what a Person would do
        public void uniInteract(Person q) {
            for ( int i = 0; i<100; i++)
                super.uniInteract(q);
        }
    }

(c) The indices are wrong: p[0] not p[1] for Spike, p[1] not p[2] for Buffy.
    Spike rolls his die once, Buffy hers 100 times.

    Person[] p = { new Person("Spike",10), new WackyPerson("Buffy") };
    p[1].interact(p[2]); // have Spike and Buffy interact