1a sorted
1b incorrect
1c any
1d any
2a "c"
2b 4
2c exception
2d "c"
2e 0
2f "a"
3a
public class RepeatedElement extends ShapeException {
  public RepeatedElement(Displaceable d) {
    super(d.toString());
  }
}
3b
import java.util.*;

public class Group implements Displaceable {
  private Set<Displaceable> elts;
  public Group(Displaceable[] es)  throws RepeatedElement {
    x = y = 0;
    if (es == null || es.length == 0)
      throw new IllegalArgumentException("Need at least one element");
    elts = new HashSet<Displaceable>();
    for (Displaceable d: es) {
      if (elts.contains(d))
        throw new RepeatedElement(d);
      elts.add(d);
    }
  }
  public double getX() {
    double x = 0;
    for (Displaceable d: elts)
      x += d.getX();
    x /= elts.size();
  }
  public double getY() {
    double y = 0;
    for (Displaceable d: elts)
      y += d.getY();
    y /= elts.size();
  }
  public void move(double dx, double dy) {
    for (Displaceable d: elts)
      d.move(dx, dy);
    }
  }
}

3c
public Set<Displaceable> primitives() {
  Set<Displaceable> p = new HashSet<Displaceable>();
  for (Displaceable d: elts) {
    if (d instanceof Group) 
      elts.addAll(((Group)d)primitives());
    else
      elts.add(d);
  }
  return p;
}

3d
public void merge(Group g) {
  elts.addAll(g.elts);
}

4a

SearchTree<String> t1 = SearchTree.newTree(null, "d", null);
SearchTree<String> t2 = SearchTree.newTree(null, "a", t1);
SearchTree<String> t3 = SearchTree.newTree(null, "z", null);
SearchTree<String> t = SearchTree.newTree(t2, "h", t3);

4b

public void elements(List<E> elts) {
  if (left != null) left.elements(elts);
  elts.add(key);
  if (right != null) right.elements(elts);
}

4c

4c

public void interval(List<E> elts, E l, E r) {
  int l2k = l.compareTo(key), k2r = key.compareTo(r);
  if (l2k < 0 && left != null)
    left.interval(elts, l, r);
  if (l2k <= 0 && k2r < 0)
    key.add(elts);
  if (k2r < 0 && right != null)
    right.interval(elts, l, r);
}

5a 4
5b return t

6a

public class GiveUp extends Exception {
  public GiveUp(int n) {
    super("failed after " + n + " tries");
  }
}

6b

  private boolean ask(int guess, int tries) throws GiveUp {
    for (int t = 0; t < tries; t++) {
      ...
    }
    throw new GiveUp(tries);
  }

6c

 public void play() {
   ...
   String answer;
   try {
     while (...) {
     ...
         ... ask(guess, 3) ...
     }
     answer = "The number is " + interval.min());
   }
   catch (GiveUp e) {
     answer = "Gave up";
   }
   out.println(answer);
}

6d

No, because (max + min) / 2 is always between max and min (inclusive)