CS111 Lab 13

The programs for this lab are available in the lab13_programs folder on nike.

Task 1: Lists of Lists

In the ListOfListsLab.java file in the ListOfLists folder are skeletons for the following five methods:

public static IntList mapSum (IntListList nss);
Returns the result of applying IL.sum(IntList L) to each IntList in nss.

mapSum([ ]) = [ ]
mapSum([[ ]]) = [0]
mapSum([[1]]) = [1]
mapSum([[1], [ ]]) = [1, 0]
mapSum([[2, 1], [1], [ ]]) = [3, 1, 0]
mapSum([[3, 2, 1], [2, 1], [1], [ ]]) = [6, 3, 1, 0]
mapSum([[4, 3, 2, 1], [3, 2, 1], [2, 1], [1], [ ]]) = [10, 6, 3, 1, 0]
mapSum([[2, 4, 8], [5, 10], [3, 6, 9]]) = [14, 15, 18]

public static IntListList mapMapDouble (IntListList nss);
Returns the result of applying IL.mapDouble(IntList L) to each IntList in nss.

mapMapDouble([ ]) = [ ]
mapMapDouble([[ ]]) = [[ ]]
mapMapDouble([[1]]) = [[2]]
mapMapDouble([[1], [ ]]) = [[2], [ ]]
mapMapDouble([[2, 1], [1], [ ]]) = [[4, 2], [2], [ ]]
mapMapDouble([[3, 2, 1], [2, 1], [1], [ ]]) = [[6, 4, 2], [4, 2], [2], [ ]]
mapMapDouble([[4, 3, 2, 1], [3, 2, 1], [2, 1], [1], [ ]]) =
      [[8, 6, 4, 2], [6, 4, 2],[4, 2], [2], [ ]]
mapMapDouble([[2, 4, 8], [5, 10], [3, 6, 9]]) = [[4, 8, 16], [10, 20], [6, 12, 18]]

public static IntListList subsequences (IntList ns);
Returns a list of all subsequences of nss. A subsequence of nss is a list that is obtained from nss by deleting zero or more elements and maintaining the relative order of the undeleted elements. The order of components lists in the result returned by subsequences does not matter.

subsequences([ ]) = [[ ]]
subsequences([1]) = [[1], [ ]]
subsequences([2, 1]) = [[2, 1], [2], [1], [ ]]
subsequences([3, 2, 1]) = [[3, 2, 1], [3, 2], [3, 1], [3], [2, 1], [2], [1], [ ]]
subsequences([4, 3, 2, 1]) = [[4, 3, 2, 1], [4, 3, 2], [4, 3, 1], [4, 3],
  [4, 2, 1], [4, 2], [4, 1], [4], [3, 2, 1], [3, 2], [3, 1], [3], [2, 1], [2], [1], [ ]]

public static IntListList combination (IntListList nss);
Returns a list of a combinations possible specified by the lists in nss. Each IntList in nss specifies a set of exclusive possibilities. For example, the list [[3,4], [2,1]] means that there are two slots to fill. The first slot can be filled by either 3 or 4. The second slot can be filled by either 2 or 1. The elements of each resulting IntList should remain in the relative order of how they are specified in the original list. The order of the component lists in the result returned by combination does not matter.

combination([ ]) = [[ ]]
combination([[ ]]) = [ ]
combination([[1]]) = [[1]]
combination([[2, 1]]) = [[2], [1]]
combination([[3, 4], [2, 1]]) = [[3, 2], [3, 1], [4, 2], [4, 1]]
combination([[2, 4, 8], [5, 10], [3, 6, 9]]) =
 [[2, 5, 3], [2, 5, 6], [2, 5, 9], [2, 10, 3], [2, 10, 6], [2, 10, 9],
  [4, 5, 3], [4, 5, 6], [4, 5, 9], [4, 10, 3], [4, 10, 6], [4, 10, 9],
  [8, 5, 3], [8, 5, 6], [8, 5, 9], [8, 10, 3], [8, 10, 6], [8, 10, 9]]

Note: For combination, you may choose what to return in the case that nss is empty. It is useful to define mapMapPrepend in order to do this problem.

public static IntListList mapMapPrepend (IntList ns, IntListList nss);
Returns the result of applying mapPrepend(int n, IntListList nss) of each integer in ns to each IntList in nss.

mapMapPrepend([ ], [ ]) =  [ ]
mapMapPrepend([ ], [[ ]]) =  [ ]
mapMapPrepend([ ], [[1]]) =  [ ]
mapMapPrepend([ ], [[2, 1]]) =  [ ]
mapMapPrepend([ ], [[3, 4], [2, 1]]) =  [ ]
mapMapPrepend([1], [ ]) =  [ ]
mapMapPrepend([1], [[ ]]) =  [[1]]
mapMapPrepend([1], [[1]]) =  [[1, 1]]
mapMapPrepend([1], [[2, 1]]) =  [[1, 2, 1]]
mapMapPrepend([1], [[3, 4], [2, 1]]) =  [[1, 3, 4], [1, 2, 1]]
mapMapPrepend([2, 1], [ ]) =  [ ]
mapMapPrepend([2, 1], [[ ]]) =  [[2], [1]]
mapMapPrepend([2, 1], [[1]]) =  [[2, 1], [1, 1]]
mapMapPrepend([2, 1], [[2, 1]]) =  [[2, 2, 1], [1, 2, 1]]
mapMapPrepend([2, 1], [[3, 4], [2, 1]]) =  [[2, 3, 4], [2, 2, 1], [1, 3, 4], [1, 2, 1]]
mapMapPrepend([3, 2, 1], [ ]) =  [ ]
mapMapPrepend([3, 2, 1], [[ ]]) =  [[3], [2], [1]]
mapMapPrepend([3, 2, 1], [[1]]) =  [[3, 1], [2, 1], [1, 1]]
mapMapPrepend([3, 2, 1], [[2, 1]]) =  [[3, 2, 1], [2, 2, 1], [1, 2, 1]]
mapMapPrepend([3, 2, 1], [[3, 4], [2, 1]]) =
  [[3, 3, 4], [3, 2, 1], [2, 3, 4], [2, 2, 1], [1, 3, 4], [1, 2, 1]]

The following strategy should be taken when approaching recursive list problems:
1. Understand the problem. Make sure you understand the examples given and can do your own examples.
2. What is the base case? What should happen in the base case? What does that mean?
3. What is a smaller problem that can be solved? What is its answer?
4. What is my problem? What is its answer?
5. How can I take the answer to the subproblem (in step 3) and the extra information I have and put those together to get the final answer (in step 4).
The IntList and IntListList methods are available via the abbreviations IL and ILL, respectively.
The mapPrepend method has been provided for you.

Task 2: Graphical User Interfaces

In this part of the lab, we will create a graphical user interface to test the methods that we wrote above. A picture of the interface is shown below:

As you can see, there are buttons which allow us to create IntList and IntListLists and buttons which allow us to invoke the methods in the lab on those lists. Below is the result of creating an IntList and IntList list and then hitting one of the method buttons:

A working version of this applet is available in the Test folder. The skeleton for this applet is in the file LOLApplet.java. Follow the guidelines below for completing the applet. Remember that creating an applet can be divided into two phases: implementing the layout and implementing the behavior.

GUI Layout
- On paper, decompose the layout of the applet by looking at the screenshot above.
- Fill in the init method which should place all the main panels on the applet.
- Fill in each of the auxiliary methods. You may test each method after completing it.
- Search the Java API for methods that you don't know about. Remember that graphical user interface components are part of the java.awt package.
GUI Behavior
- Fill in the action method so that they will trigger the right methods for each of the buttons in the top panel.
- Fill in each of the action methods. Follow the comments in the skeleton for each method.
- Test this out so far.
- The action method and auxiliary methods for invoking the List of List methods on our IntList and IntListList have already been filled out. Study them to see how they work.
- In order to see the answers, fill out the displayAnswer method following the comments in the skeleton.