diff --git a/src/main/java/learnrxjava/ComposableListExercises.java b/src/main/java/learnrxjava/ComposableListExercises.java
index a13940c..bd10eb3 100644
--- a/src/main/java/learnrxjava/ComposableListExercises.java
+++ b/src/main/java/learnrxjava/ComposableListExercises.java
@@ -127,11 +127,11 @@ public <R> ComposableList<R> map(Function<T, R> projectionFunction) {
             // Note that you can apply a projectionFunction to a value like this:
             //  projectionFunction.apply(5)
             // ------------ INSERT CODE HERE! ----------------------------
-            
+            results.add(projectionFunction.apply(itemInList));
         });
         
-        //return results;
-        throw new UnsupportedOperationException("Not implemented yet.");
+        return results;
+        //throw new UnsupportedOperationException("Not implemented yet.");
     }
     
     /*
@@ -148,8 +148,7 @@ public static ComposableList<JSON> exercise5() {
             new Video(675465, "Fracture", 5.0));
          
         // complete this expression 
-        // return newReleases.map(video -> 
-        throw new UnsupportedOperationException("Not implemented yet.");
+        return newReleases.map(video ->  json("id", video.id, "title", video.title));
     }
 
     /*
@@ -189,11 +188,12 @@ public static ComposableList<Video> exercise6() {
         newReleases.forEach(video -> {
             // Insert code here that adds a video to the highRatedVideos list
             // if it has a rating of 5.0.
-
+            if(video.rating == 5) {
+                highRatedVideos.add(video);
+            }
         });
         
-        // return highRatedVideos;
-        throw new UnsupportedOperationException("Not implemented yet.");        
+        return highRatedVideos;
     }
     
     /*
@@ -221,11 +221,13 @@ public ComposableList<T> filter(Predicate<T> predicateFunction) {
             // Note: you can apply the predicateFunction to a value like this:
             // predicateFunction.test(5)
             // ------------ INSERT CODE HERE! ----------------------------
+             if(predicateFunction.test(itemInList)) {
+                 results.add(itemInList);
+             }
 
         });
 
-        // return results;
-        throw new UnsupportedOperationException("Not implemented yet.");
+        return results;
     }
 
     /*
@@ -264,9 +266,9 @@ public static ComposableList<Integer> exercise8() {
         // Chain the filter and map functions to select the id of all videos
         // with a rating of 5.0.
         // ------------ INSERT CODE HERE! -----------------------------------
-        //return newReleases // Complete this expression
+        return newReleases.filter(video -> video.rating == 5).map(video -> video.id);
 
-        throw new UnsupportedOperationException("Not implemented yet.");
+        //throw new UnsupportedOperationException("Not implemented yet.");
     }
 
     /*
@@ -300,8 +302,12 @@ public static ComposableList<Integer> exercise9() {
         // Use two nested forEach loops to flatten the movieLists into a list of
         // video ids.
         // ------------   INSERT CODE HERE!  -----------------------------------
-        //return allVideoIdsInMovieLists;
-        throw new UnsupportedOperationException("Not implemented yet.");
+        for (MovieList movieList : movieLists) {
+            for (Video movie : movieList.videos) {
+                allVideoIdsInMovieLists.add(movie.id);
+            }
+        }
+        return allVideoIdsInMovieLists;
     }
     
     /*
@@ -327,10 +333,10 @@ public static ComposableList<Integer> exercise9() {
 
     ComposableList.of(0, 10, 20, 100, 110, 120, 200, 210, 220)
      */   
-    public <R> ComposableList<R> concatMap(
-        Function<T, ComposableList<R>> projectionFunctionThatReturnsList) {
+    public <R> ComposableList<R> concatMap(Function<T, ComposableList<R>> projectionFunctionThatReturnsList) {
         ComposableListExercises<R> results = new ComposableListExercises<R>();
         for (T itemInList : this) {
+
             // ------------ INSERT CODE HERE! ----------------------------
             // Apply the projection function to each item in the list.
             // This will create _another_ list. Then loop through each
@@ -338,11 +344,13 @@ public <R> ComposableList<R> concatMap(
             // Note that you can apply a projectionFunction to a value like this:
             // projectionFunctionThatReturnsList.apply(5)
             // ------------ INSERT CODE HERE! ----------------------------
-
+            for (R ele : projectionFunctionThatReturnsList.apply(itemInList)){
+                results.add(ele);
+            }
         }
         
-        //return results;
-        throw new UnsupportedOperationException("Not implemented yet.");
+        return results;
+        //throw new UnsupportedOperationException("Not implemented yet.");
     }
     
     /*
@@ -372,11 +380,11 @@ public static ComposableList<Integer> exercise11() {
         // return movieLists // finish expression
         // ------------   INSERT CODE HERE!  -----------------------------------
         // **************ANSWER START***************//
-        // return movieLists.
-        //     concatMap(movieList -> 
-        //         movieList.videos.map(video -> video.id));
+        return movieLists.
+             concatMap(movieList ->
+                 movieList.videos.map(video -> video.id));
         // **************ANSWER END***************//
-        throw new UnsupportedOperationException("Not implemented yet.");
+        //throw new UnsupportedOperationException("Not implemented yet.");
     }
     
     /*
@@ -449,8 +457,13 @@ public static ComposableList<JSON> exercise12() {
         //   {"id": 675465,"title": "Fracture","boxart":"http://cdn-0.nflximg.com/images/2891/Fracture150.jpg" },
         // };
 
-        // return movieLists // Complete this expression!
-        throw new UnsupportedOperationException("Not implemented yet.");
+        return movieLists
+                .concatMap(video->video.videos)
+                .map(video -> json("id", video.id, "title", video.title, "boxart", video.boxarts
+                                                                                    .filter(b -> b.width == 150 && b.height == 200)
+                                                                                    .get(0).url));
+        // Complete this expression!
+        //throw new UnsupportedOperationException("Not implemented yet.");
     }
 
     /*
@@ -483,14 +496,13 @@ public static BoxArt exercise13() {
             for (BoxArt boxart: boxarts) {
                 currentSize = boxart.width * boxart.height;
                 if (currentSize > maxSize) {
-                    // ****** INSERT CODE HERE ********
-                    // Assign the largestBoxart to the current boxart, and assign the maxSize to the currentSize.
-                    // ****** INSERT CODE HERE ********
+                    largestBoxart=boxart;
+                    maxSize=currentSize;
                 }
             }
 
-        // return largestBoxart;
-        throw new UnsupportedOperationException("Not implemented yet.");
+        return largestBoxart;
+        //throw new UnsupportedOperationException("Not implemented yet.");
     }
     /*
     Exercise 14: Implement reduce()
@@ -520,6 +532,7 @@ public ComposableList<T> reduce(BiFunction<T, T, T> combiner) {
             // ************ INSERT CODE HERE **************
             //  if the list is empty, return this
             // ********************************************
+            return this;
         } else {
             accumulatedValue = this.get(0);
 
@@ -531,14 +544,14 @@ public ComposableList<T> reduce(BiFunction<T, T, T> combiner) {
                 // Set accumulatedValue to the result of passing accumulatedValue and the list value at the 
                 // counter index to the combiner function.
                 // ****** INSERT CODE HERE ********
-
+                accumulatedValue=combiner.apply(accumulatedValue,this.get(counter));
                 counter++;
             }
 
-            //return ComposableListExercises.of(accumulatedValue);
+            return ComposableListExercises.of(accumulatedValue);
         }
 
-        throw new UnsupportedOperationException("Not implemented yet.");
+        //throw new UnsupportedOperationException("Not implemented yet.");
     }
 
     /*
@@ -596,9 +609,10 @@ public static ComposableList<Integer> exercise16() {
         // returns a list with one item.
 
         // complete the expression below
-        //return ratings.reduce
+        //return ratings.reduce(ratings.get(0),(a,b) -> { if(a>b) return a; else return b;});
+        return ratings.reduce(ratings.get(0),(a,b) -> a > b ? a : b);
 
-        throw new UnsupportedOperationException("Not implemented yet.");
+        //throw new UnsupportedOperationException("Not implemented yet.");
     }
     /*
     Exercise 17: Retrieve url of the largest boxart
@@ -616,8 +630,11 @@ public static ComposableList<String> exercise17() {
 
         // You should return a list containing only the largest box art. Remember that reduce always
         // returns a list with one item.
-        // return boxarts.reduce  
-        throw new UnsupportedOperationException("Not implemented yet.");
+        return boxarts.reduce(boxarts.get(0), (a,b) -> {
+            if(a.width * a.height > b.width * b.height) return a;
+            else return b;
+        }).map(b->b.url);
+        //throw new UnsupportedOperationException("Not implemented yet.");
     }
 
     /*
@@ -677,7 +694,10 @@ public static ComposableList<Map<Integer, String>> exercise18() {
                 // exercise simply copy the accumulatedMap into a new map, add the video information to the copy, 
                 // and return the copy.
                 // ************ INSERT CODE HERE ************
-                throw new UnsupportedOperationException("Not implemented yet.");
+                //throw new UnsupportedOperationException("Not implemented yet.");
+
+                accumulatedMap.put(video.id, video.title);
+                return accumulatedMap;
             });
     }
 
@@ -750,13 +770,18 @@ public static ComposableList<JSON> exercise19() {
         // ];
 
         // Uncomment the code below and finish the expression.
-        /*
-        return movieLists.
-            concatMap(movieList -> {
 
-            })
-         */
-        throw new UnsupportedOperationException("Not implemented yet.");
+        return movieLists
+            .concatMap(movieList -> movieList.videos)
+                .map(video->{
+                    String smallestBoxArt = video.boxarts.reduce((a, b) -> {
+                        if(a.width * a.height > b.width * b.height) return b;
+                        else return a;
+                    }).get(0).url;
+                    return json("id", video.id, "title", video.title, "boxart", smallestBoxArt);
+                });
+
+        //throw new UnsupportedOperationException("Not implemented yet.");
     }
 
     /*
@@ -805,10 +830,11 @@ public static ComposableList<JSON> exercise20() {
         for (int counter = 0; counter < Math.min(videos.size(), bookmarks.size()); counter++) {
             // Insert code here to create a {"videoId" : videoId, "bookmarkId" : bookmarkId} JSON 
             // using json() and add it to the videoIdAndBookmarkIdPairs list.
+            videoIdAndBookmarkIdPairs.add(json("videoId", videos.get(counter).id, "bookmarkId", bookmarks.get(counter).id));
         }
 
-        // return videoIdAndBookmarkIdPairs;
-        throw new UnsupportedOperationException("Not implemented yet.");
+        return videoIdAndBookmarkIdPairs;
+        // throw new UnsupportedOperationException("Not implemented yet.");
     }
 
     /*
@@ -831,10 +857,11 @@ public static <T0,T1,R> ComposableList<R> zip(ComposableList<T0> left, Composabl
         for (int counter = 0; counter < Math.min(left.size(), right.size()); counter++) {
             // Add code here to apply the combinerFunction to the left and right-hand items in the 
             // respective lists, and add the result to the results List
+            results.add(combinerFunction.apply(left.get(counter), right.get(counter)));
         }
 
-        // return results;
-        throw new UnsupportedOperationException("Not implemented yet.");
+        return results;
+        //throw new UnsupportedOperationException("Not implemented yet.");
     }
 
     /*
@@ -875,8 +902,10 @@ public static ComposableList<JSON> exercise22() {
         );
 
         //... finish this expression
-        // return ComposableListExercises.zip( 
-        throw new UnsupportedOperationException("Not implemented yet.");
+        return ComposableListExercises.zip(videos.map(video -> video.id),
+                                           bookmarks.map(bookmark -> bookmark.id),
+                                           (a, b) -> json("videoId", a, "bookmarkId", b));
+        //throw new UnsupportedOperationException("Not implemented yet.");
     }
 
     /*
@@ -963,14 +992,18 @@ public static ComposableList<JSON> exercise23() {
         );
 
         //------------ COMPLETE THIS EXPRESSION --------------
-        /*
+
+
         return movieLists.
-            concatMap(movieList -> {
+            concatMap(movieList -> movieList.videos)
+                .map(video->{
+                    int time = video.interestingMoments.filter(i->i.type=="Middle").get(0).time;
+                    String url=video.boxarts.reduce((a,b) -> a.width * a.height < b.width * b.height ? a : b).get(0).url;
+                    return json("id", video.id, "title", video.title, "time", time, "url", url);
+                });
 
-            });
-        */
 
-        throw new UnsupportedOperationException("Not implemented yet.");
+        // throw new UnsupportedOperationException("Not implemented yet.");
     }
 
 
diff --git a/src/main/java/learnrxjava/ComposableListSolutions.java b/src/main/java/learnrxjava/ComposableListSolutions.java
index c2256d2..2ac1d4d 100644
--- a/src/main/java/learnrxjava/ComposableListSolutions.java
+++ b/src/main/java/learnrxjava/ComposableListSolutions.java
@@ -15,14 +15,15 @@
 import learnrxjava.types.JSON;
 import learnrxjava.types.MovieList;
 import learnrxjava.types.Video;
+import rx.functions.Action1;
 
 /**
- * Mastering concurrency is challenging, But we can make it much easier by simply choosing the right 
- * abstraction to model an asynchronous operation, and then using simple composition operations to 
+ * Mastering concurrency is challenging, But we can make it much easier by simply choosing the right
+ * abstraction to model an asynchronous operation, and then using simple composition operations to
  * glue different instances of these abstractions together to build solutions to complex problems.
- * 
- * To learn how stream composition works, we will first learn how to use the composition methods 
- * (map, filter, flatMap, reduce, zip) to compose together a data structure with which most developers 
+ *
+ * To learn how stream composition works, we will first learn how to use the composition methods
+ * (map, filter, flatMap, reduce, zip) to compose together a data structure with which most developers
  * are already familiar: a list.
  */
 public class ComposableListSolutions<T> extends ArrayList<T> implements ComposableList<T> {
@@ -92,11 +93,11 @@ public static ComposableList<JSON> exercise3() {
                 new Video(675465, "Fracture", 5.0));
 
         ComposableListSolutions<JSON> videoAndTitlePairs = new ComposableListSolutions<JSON>();
-        
+
         newReleases.forEach(video -> {
            videoAndTitlePairs.add(json("id", video.id, "title", video.title));
         });
-        
+
         return videoAndTitlePairs;
     }
 
@@ -110,8 +111,8 @@ public static ComposableList<JSON> exercise3() {
 
     Why not create a helper method for these common operations?
 
-    If our ComposableList had a map() method, it would make projections easier. 
-    The map method accepts the projection function to be applied to each item 
+    If our ComposableList had a map() method, it would make projections easier.
+    The map method accepts the projection function to be applied to each item
     in the source List, and returns a List of the projected results.
 
     ComposableList.of(1,2,3).map(x -> x + 1) is equivalent to ComposableList.of(2,3,4)
@@ -129,14 +130,14 @@ public <R> ComposableList<R> map(Function<T, R> projectionFunction) {
             // ------------ INSERT CODE HERE! ----------------------------
             results.add(projectionFunction.apply(itemInList));
         });
-        
+
         return results;
     }
-    
+
     /*
     Exercise 5: Use map() to project a ComposableList of videos into a stream of {id,title} JSON
 
-    Let's repeat exercise 3 and collect {id, title} JSON for each video in newReleases, but this time we'll 
+    Let's repeat exercise 3 and collect {id, title} JSON for each video in newReleases, but this time we'll
     use ComposableList's map method instead of the forEach method.
     */
     public static ComposableList<JSON> exercise5() {
@@ -145,20 +146,20 @@ public static ComposableList<JSON> exercise5() {
             new Video(654356453, "Bad Boys", 5.0),
             new Video(65432445, "The Chamber", 4.0),
             new Video(675465, "Fracture", 5.0));
-         
-        // complete this expression 
+
+        // complete this expression
         return newReleases.map(video -> {
-           return json("id", video.id, "title", video.title); 
+           return json("id", video.id, "title", video.title);
         });
     }
 
     /*
     Exercise 6: Filtering Lists
 
-    Like projection, filtering a list is also a very common operation. To filter a list we apply a test to each 
+    Like projection, filtering a list is also a very common operation. To filter a list we apply a test to each
     item and collect the items that pass into a new list.
 
-    Use forEach() to loop through the videos in the newReleases list and, if a video has a rating of 5.0, add it 
+    Use forEach() to loop through the videos in the newReleases list and, if a video has a rating of 5.0, add it
     to the videos list.
      */
     public static ComposableList<Video> exercise6() {
@@ -184,19 +185,10 @@ public static ComposableList<Video> exercise6() {
                     5.0
             ));
 
-        ComposableListSolutions<Video> highRatedVideos = new ComposableListSolutions<Video>();
+        return newReleases.filter(video -> video.rating == 5);
 
-        newReleases.forEach(video -> {
-            // Insert code here that adds a video to the highRatedVideos list
-            // if it has a rating of 5.0.
-            if(video.rating == 5) {
-                highRatedVideos.add(video);
-            }
-        });
-        
-        return highRatedVideos;
     }
-    
+
     /*
     Exercise 7: Implement filter()
 
@@ -221,11 +213,11 @@ public ComposableList<T> filter(Predicate<T> predicateFunction) {
             // result is true, add the result to the results list.
             // Note: you can apply the predicateFunction to a value like this:
             // predicateFunction.test(5)
-            
+
             if(predicateFunction.test(itemInList)) {
                 results.add(itemInList);
             }
-            
+
             // ------------ INSERT CODE HERE! ----------------------------
         });
 
@@ -235,7 +227,7 @@ public ComposableList<T> filter(Predicate<T> predicateFunction) {
     /*
     Exercise 8: Query Data by Chaining Method Calls
 
-    The map() and filter() functions let us express what data we want without requiring us to specify how the 
+    The map() and filter() functions let us express what data we want without requiring us to specify how the
     data is collected. They can also be combined to create more complex queries.
     In this Exercise, we will chain map and filter to collect the IDs of videos that have a rating of 5.0.
 
@@ -267,7 +259,7 @@ public static ComposableList<Integer> exercise8() {
         // ------------ INSERT CODE HERE! -----------------------------------
         // Chain the filter and map functions to select the id of all videos
         // with a rating of 5.0.
-        
+
         return newReleases.filter(v -> v.rating == 5).map(v -> v.id);
 
         // ------------ INSERT CODE HERE! -----------------------------------
@@ -276,13 +268,13 @@ public static ComposableList<Integer> exercise8() {
     /*
     Exercise 9: Querying Trees
 
-    Chaining together map() and filter() gives us a lot of expressive power. These high level functions let us 
-    express _what_ data we want, instead of specifying _how_ we want it retrieved. Queries written with map and 
-    filter are general enough to be applied to any data source including Lists, Java 8 Streams, and Reactive Streams. 
-    That means that our queries can easily be modified to run in parallel or asynchronously simply by switching 
+    Chaining together map() and filter() gives us a lot of expressive power. These high level functions let us
+    express _what_ data we want, instead of specifying _how_ we want it retrieved. Queries written with map and
+    filter are general enough to be applied to any data source including Lists, Java 8 Streams, and Reactive Streams.
+    That means that our queries can easily be modified to run in parallel or asynchronously simply by switching
     the underlying data source from a List to a Java 8 Parallel Stream or an Rx Observable respectively.
 
-    In addition to flat lists, sometimes we need to query Trees. In the exercise below, we will use two nested 
+    In addition to flat lists, sometimes we need to query Trees. In the exercise below, we will use two nested
     forEach() calls to retrieve the video IDs from each movieList and accumulate the results into a new List.
      */
     public static ComposableList<Integer> exercise9() {
@@ -303,7 +295,7 @@ public static ComposableList<Integer> exercise9() {
         // ------------   INSERT CODE HERE!  -----------------------------------
         // Use two nested forEach loops to flatten the movieLists into a list of
         // video ids.
-        
+
         movieLists.forEach(ml -> {
             ml.videos.forEach(v -> {
                 allVideoIdsInMovieLists.add(v.id);
@@ -311,22 +303,22 @@ public static ComposableList<Integer> exercise9() {
         });
 
         // ------------   INSERT CODE HERE!  -----------------------------------
-        
+
         return allVideoIdsInMovieLists;
     }
-    
+
     /*
     Exercise 10: Implement concatMap()
 
-    To flatten trees with nested forEach expressions we accumlate the results in a new flat list. Querying a List 
-    of data from a Tree is a very common operation. Ideally we'd be able to use a helper function to do the heavy 
-    lifting for us. 
+    To flatten trees with nested forEach expressions we accumlate the results in a new flat list. Querying a List
+    of data from a Tree is a very common operation. Ideally we'd be able to use a helper function to do the heavy
+    lifting for us.
 
-    Let's implement the concatMap() method for List. Like map(), the concatMap() function applies a projection 
-    function to each item in a list. However the projection function passed to concatMap tranforms each individual 
-    value into a _list of values_, creating a tree structure. Before returning the tree, the concatMap method 
+    Let's implement the concatMap() method for List. Like map(), the concatMap() function applies a projection
+    function to each item in a list. However the projection function passed to concatMap tranforms each individual
+    value into a _list of values_, creating a tree structure. Before returning the tree, the concatMap method
     flattens the tree by concatenating each inner list together in order. Here's an example of concatMap in action:
-    
+
     ComposableList
         .of(
             ComposableList.of( 0,   1,   2),
@@ -337,7 +329,7 @@ public static ComposableList<Integer> exercise9() {
     is equivalent to
 
     ComposableList.of(0, 10, 20, 100, 110, 120, 200, 210, 220)
-     */   
+     */
     public <R> ComposableList<R> concatMap(
         Function<T, ComposableList<R>> projectionFunctionThatReturnsList) {
         ComposableListSolutions<R> results = new ComposableListSolutions<R>();
@@ -348,7 +340,7 @@ public <R> ComposableList<R> concatMap(
             // inner list and add each item to the results list.
             // Note that you can apply a projectionFunction to a value like this:
             // projectionFunctionThatReturnsList.apply(5)
-            
+
             ComposableList<R> l = projectionFunctionThatReturnsList.apply(itemInList);
             l.forEach(r -> {
                 results.add(r);
@@ -356,13 +348,13 @@ public <R> ComposableList<R> concatMap(
 
             // ------------ INSERT CODE HERE! ----------------------------
         }
-        
+
         return results;
     }
-    
+
     /*
-    As you may have already guessed, the ComposableList class has the concatMap method. The concatMap method 
-    may seem pretty abstract at first, and it may not be immediately obvious how it can be used to transform 
+    As you may have already guessed, the ComposableList class has the concatMap method. The concatMap method
+    may seem pretty abstract at first, and it may not be immediately obvious how it can be used to transform
     data in a tree. In the next exercise we will combine this function with the map function to query a tree.
 
     exercise 11: Use map() and concatMap() to project and flatten the movieLists into a stream of video ids
@@ -388,22 +380,22 @@ public static ComposableList<Integer> exercise11() {
         // ------------   INSERT CODE HERE!  -----------------------------------
         // **************ANSWER START***************//
          return movieLists.
-             concatMap(movieList -> 
+             concatMap(movieList ->
                  movieList.videos.map(video -> video.id));
         // **************ANSWER END***************//
     }
-    
+
     /*
     exercise 12: Retrieve id, title, and a 150x200 box art url for every video
 
-    Mastering the combination of map() and concatMap() is key to effective functional programming. You're half way 
+    Mastering the combination of map() and concatMap() is key to effective functional programming. You're half way
     there! Let's try a more complicated example...
 
-    You've managed to flatten a tree that's two levels deep, let's try for three! Let's say that instead of a 
-    single boxart url on each video, we had a collection of boxart objects, each with a different size and url. 
-    Create a query that selects {id, title, boxart} json for every video in the movieLists. This time though, 
-    the boxart property in the result will be the url of the boxart object with dimensions of 150x200px. Let's 
-    see if you can solve this problem using _only_ map(), concatMap(), and filter(). No other methods are allowed, 
+    You've managed to flatten a tree that's two levels deep, let's try for three! Let's say that instead of a
+    single boxart url on each video, we had a collection of boxart objects, each with a different size and url.
+    Create a query that selects {id, title, boxart} json for every video in the movieLists. This time though,
+    the boxart property in the result will be the url of the boxart object with dimensions of 150x200px. Let's
+    see if you can solve this problem using _only_ map(), concatMap(), and filter(). No other methods are allowed,
     including the List::get method.
     */
     public static ComposableList<JSON> exercise12() {
@@ -467,7 +459,7 @@ public static ComposableList<JSON> exercise12() {
            return ml.videos.concatMap(v -> {
                ComposableList<BoxArt> boxart = v.boxarts.filter(ba -> ba.width == 150 && ba.height == 200);
                return boxart.map(ba -> {
-                   return json("id", v.id, "title", v.title, "boxart", ba.url);                   
+                   return json("id", v.id, "title", v.title, "boxart", ba.url);
                });
            });
         });
@@ -476,15 +468,15 @@ public static ComposableList<JSON> exercise12() {
     /*
     Exercise 13: Reducing Lists
 
-    Sometimes we need to aggregate the values in a collection and produce a single value. For example let's say 
-    we need to find the largest integer in a list. We can't use a filter() operation, because it only examines 
+    Sometimes we need to aggregate the values in a collection and produce a single value. For example let's say
+    we need to find the largest integer in a list. We can't use a filter() operation, because it only examines
     one item at a time. To find the largest integer we need to compare at least two values at a time.
 
-    One approach could be to select an item in the list as the assumed largest number (perhaps the first item), 
-    and then compare that value to every other item in the list. Each time we come across a number that was 
+    One approach could be to select an item in the list as the assumed largest number (perhaps the first item),
+    and then compare that value to every other item in the list. Each time we come across a number that was
     larger than our assumed largest number we'd replace the assumed largest value with the larger value and continue.
 
-    In this example we use a loop to find the largest box art. Each time we examine a new boxart we update a 
+    In this example we use a loop to find the largest box art. Each time we examine a new boxart we update a
     variable with the currently known maximumSize. If the boxart is smaller than the maximum size, we discard it.
     If it's larger, we keep track of it. Finally we're left with a single boxart which must necessarily be the largest.
     */
@@ -516,21 +508,21 @@ public static BoxArt exercise13() {
     /*
     Exercise 14: Implement reduce()
 
-    Combining the value produced from the last computation with each value until a single value is produced 
-    is a very common pattern. Many types of operations require us to process at least two items a time like 
-    computing the minimum or the maximum value in a List. Let's create a helper function called reduce() to 
+    Combining the value produced from the last computation with each value until a single value is produced
+    is a very common pattern. Many types of operations require us to process at least two items a time like
+    computing the minimum or the maximum value in a List. Let's create a helper function called reduce() to
     aggregate a single value from a list of values.
 
-    Reduce recursively combines the results of the last aggregation with the next item in the list until the 
-    values in the list are exhausted, and then returns a list containing only the last aggregation value. 
-    Reduce uses the first value in the list as the initial aggregation value. For example 
-    ComposableList.of(1,2,3).reduce((acc,curr) -> acc + curr) is structurally equivalent to ComposableList.of(6).  
-    In the previous example, theBinary function is invoked three times. 
+    Reduce recursively combines the results of the last aggregation with the next item in the list until the
+    values in the list are exhausted, and then returns a list containing only the last aggregation value.
+    Reduce uses the first value in the list as the initial aggregation value. For example
+    ComposableList.of(1,2,3).reduce((acc,curr) -> acc + curr) is structurally equivalent to ComposableList.of(6).
+    In the previous example, theBinary function is invoked three times.
 
-    The first time the binary lambda function is invoked the accumulated value acc is 1 (the first value in the 
-    list) and the current value curr is 2 (the second value in the list). The next time the binary lambda function 
-    is invoked, the accumulated value is the result of the previous function invocation (3) and the current value 
-    is the next value in the list (3).  
+    The first time the binary lambda function is invoked the accumulated value acc is 1 (the first value in the
+    list) and the current value curr is 2 (the second value in the list). The next time the binary lambda function
+    is invoked, the accumulated value is the result of the previous function invocation (3) and the current value
+    is the next value in the list (3).
      */
     public ComposableList<T> reduce(BiFunction<T, T, T> combiner) {
         int counter = 1;
@@ -550,11 +542,11 @@ public ComposableList<T> reduce(BiFunction<T, T, T> combiner) {
             // we've exhausted the entire list and are left with only one function.
             while (counter < this.size()) {
                 // ****** INSERT CODE HERE ********
-                // Set accumulatedValue to the result of passing accumulatedValue and the list value at the 
+                // Set accumulatedValue to the result of passing accumulatedValue and the list value at the
                 // counter index to the combiner function.
-                
+
                 accumulatedValue = combiner.apply(accumulatedValue, this.get(counter));
-                
+
                 // ****** INSERT CODE HERE ********
 
                 counter++;
@@ -567,16 +559,16 @@ public ComposableList<T> reduce(BiFunction<T, T, T> combiner) {
     /*
     Exercise 15: Implement a reduce overload that accepts an initial value
 
-    Sometimes when we reduce a list, we want the final reduced value to be a different type than the items 
-    stored in the list. For example, let's say we have a list of videos and we want to reduce them to a 
+    Sometimes when we reduce a list, we want the final reduced value to be a different type than the items
+    stored in the list. For example, let's say we have a list of videos and we want to reduce them to a
     single map where the key is the video id and the value is the video's title.
 
-    This overload of reduce accepts a initial value, which is used as the accumulated value the first time 
-    the binary function is run instead of the first item in the List. Just as in the previous implementation 
-    of reduce, the results of the previous function invocation and the current item in the list are passed 
-    to the binary function recursively until there are no more items in the list to reduce. Finally The 
-    reduce method produces a list containing only a single reduced value. Note that binary function will 
-    always return the same type as the initial accumulated value. 
+    This overload of reduce accepts a initial value, which is used as the accumulated value the first time
+    the binary function is run instead of the first item in the List. Just as in the previous implementation
+    of reduce, the results of the previous function invocation and the current item in the list are passed
+    to the binary function recursively until there are no more items in the list to reduce. Finally The
+    reduce method produces a list containing only a single reduced value. Note that binary function will
+    always return the same type as the initial accumulated value.
 
     ComposableList
         .of(
@@ -608,7 +600,7 @@ public <R> ComposableList<R> reduce(R initialValue, BiFunction<R, T, R> combiner
         }
     }
 
-    /*        
+    /*
     Exercise 16: Retrieve the largest rating.
 
     Use the right reduce overload to select the maximum value in a list of ratings.
@@ -630,7 +622,7 @@ public static ComposableList<Integer> exercise16() {
     /*
     Exercise 17: Retrieve url of the largest boxart
 
-    Now let's try combining reduce() with our other functions to build more complex queries. Let's try combining 
+    Now let's try combining reduce() with our other functions to build more complex queries. Let's try combining
     reduce() with map() to reduce multiple boxart objects to a single value: the url of the largest box art.
      */
     public static ComposableList<String> exercise17() {
@@ -657,8 +649,8 @@ public static ComposableList<String> exercise17() {
     /*
     Exercise 18: Reducing with an initial value
 
-    Sometimes when we reduce a list, we want the reduced value to be a different type than the items stored 
-    in the list. Let's say we have a list of videos and we want to reduce them to a single map where the key 
+    Sometimes when we reduce a list, we want the reduced value to be a different type than the items stored
+    in the list. Let's say we have a list of videos and we want to reduce them to a single map where the key
     is the video id and the value is the video's title.
      */
     public static ComposableList<Map<Integer, String>> exercise18() {
@@ -703,17 +695,17 @@ public static ComposableList<Map<Integer, String>> exercise18() {
             new HashMap<Integer, String> (),
             (accumulatedMap, video) -> {
                 // ************ INSERT CODE HERE ************
-                // Remember that you the functions passed to map, filter, concatMap, reduce, and zip can only 
-                // change objects created inside the function. That means that you cannot simply add the video to 
+                // Remember that you the functions passed to map, filter, concatMap, reduce, and zip can only
+                // change objects created inside the function. That means that you cannot simply add the video to
                 // the accumulatedMap. You must make a copy of the accumulated map, and add the video title to that.
-                // Granted, this is very inefficient. However there are libraries that provide immutable maps to make 
-                // copying maps very efficient, allowing this to be a viable approach. For the purpose of this 
-                // exercise simply copy the accumulatedMap into a new map, add the video information to the copy, 
+                // Granted, this is very inefficient. However there are libraries that provide immutable maps to make
+                // copying maps very efficient, allowing this to be a viable approach. For the purpose of this
+                // exercise simply copy the accumulatedMap into a new map, add the video information to the copy,
                 // and return the copy.
                 // ************ INSERT CODE HERE ************
-                
+
                 accumulatedMap.put(video.id, video.title);
-                
+
                 return accumulatedMap;
             });
     }
@@ -722,9 +714,9 @@ public static ComposableList<Map<Integer, String>> exercise18() {
     Exercise 19: Retrieve the id, title, and smallest box art url for every video.
 
     Nice work. Now let's try combining reduce() with our other functions to build more complex queries.
-    
-    This is a variation of the problem we solved earlier, where we retrieved the url of the boxart with a 
-    width of 150px. This time we'll use reduce() instead of filter() to retrieve the _smallest_ box art in 
+
+    This is a variation of the problem we solved earlier, where we retrieved the url of the boxart with a
+    width of 150px. This time we'll use reduce() instead of filter() to retrieve the _smallest_ box art in
     the boxarts list.
      */
     public static ComposableList<JSON> exercise19() {
@@ -808,12 +800,12 @@ public static ComposableList<JSON> exercise19() {
     /*
     Exercise 20: Zipping Lists
 
-    Sometimes we need to combine the items in two different list by index. If you visualize a zipper, where each 
-    side is a list, and each tooth is an item, you'll have a good idea of how the zip operation works. Before we 
+    Sometimes we need to combine the items in two different list by index. If you visualize a zipper, where each
+    side is a list, and each tooth is an item, you'll have a good idea of how the zip operation works. Before we
     learn about zip() though, we'll solve a similar problem using forEach.
 
-    In this exercise we'll combine videos and bookmarks by index. Use the forEach method to traverse the videos 
-    and bookmarks list at the same time. For each video and bookmark pair, create a {videoId, bookmarkId} JSON 
+    In this exercise we'll combine videos and bookmarks by index. Use the forEach method to traverse the videos
+    and bookmarks list at the same time. For each video and bookmark pair, create a {videoId, bookmarkId} JSON
     and add it to the videoIdAndBookmarkIdPairs list.
     */
     public static ComposableList<JSON> exercise20() {
@@ -839,7 +831,7 @@ public static ComposableList<JSON> exercise20() {
                         5.0
                 )
         );
-        
+
         ComposableListSolutions<Bookmark> bookmarks = ComposableListSolutions.of(
                 new Bookmark(470, 23432),
                 new Bookmark(453, 234324),
@@ -849,7 +841,7 @@ public static ComposableList<JSON> exercise20() {
         ComposableListSolutions<JSON> videoIdAndBookmarkIdPairs = new ComposableListSolutions<JSON>();
 
         for (int counter = 0; counter < Math.min(videos.size(), bookmarks.size()); counter++) {
-            // Insert code here to create a {"videoId" : videoId, "bookmarkId" : bookmarkId} JSON 
+            // Insert code here to create a {"videoId" : videoId, "bookmarkId" : bookmarkId} JSON
             // using json() and add it to the videoIdAndBookmarkIdPairs list.
             videoIdAndBookmarkIdPairs.add(json("videoId", videos.get(counter).id, "bookmarkId", bookmarks.get(counter).id));
         }
@@ -860,22 +852,22 @@ public static ComposableList<JSON> exercise20() {
     /*
     Exercise 21: Implement zip
 
-    Let's add a static zip() function to the ComposableList type. 
-    The zip function accepts a combiner binary function, traverses each list at the same time, and calls 
-    the combiner function on the current item on the left-hand-side and right-hand-side. The zip function 
-    requires an item from each list in order to call the combiner function, therefore the list returned by 
+    Let's add a static zip() function to the ComposableList type.
+    The zip function accepts a combiner binary function, traverses each list at the same time, and calls
+    the combiner function on the current item on the left-hand-side and right-hand-side. The zip function
+    requires an item from each list in order to call the combiner function, therefore the list returned by
     zip will only be as large as the smallest input list.
 
     ComposableList.zip(
-        ComposableList.of(1,2,3), 
-        ComposableList.of(4,5,6), 
+        ComposableList.of(1,2,3),
+        ComposableList.of(4,5,6),
         (x,y) -> x + y) is structurally equivalent to ComposableList.of(5,7,9)
      */
     public static <T0,T1,R> ComposableList<R> zip(ComposableList<T0> left, ComposableList<T1> right, BiFunction<T0,T1, R> combinerFunction) {
         ComposableListSolutions<R> results = new ComposableListSolutions<R>();
 
         for (int counter = 0; counter < Math.min(left.size(), right.size()); counter++) {
-            // Add code here to apply the combinerFunction to the left and right-hand items in the 
+            // Add code here to apply the combinerFunction to the left and right-hand items in the
             // respective lists, and add the result to the results List
             results.add(combinerFunction.apply(left.get(counter), right.get(counter)));
         }
@@ -913,7 +905,7 @@ public static ComposableList<JSON> exercise22() {
                 5.0
             )
         );
-        
+
         ComposableListSolutions<Bookmark> bookmarks = ComposableListSolutions.of(
             new Bookmark(470, 23432),
             new Bookmark(453, 234324),
@@ -922,18 +914,18 @@ public static ComposableList<JSON> exercise22() {
 
         //... finish this expression
         return ComposableListSolutions.zip(
-                videos.map(v -> v.id), 
-                bookmarks.map(b -> b.id), 
+                videos.map(v -> v.id),
+                bookmarks.map(b -> b.id),
                 (v, b) -> json("videoId", v, "bookmarkId", b));
     }
 
     /*
     Exercise 23: Retrieve each video's id, title, middle interesting moment time, and smallest box art url.
 
-    This is a variation of the problem we solved earlier. This time each video has an interesting moments 
-    collection, each representing a time during which a screenshot is interesting or representative of the 
-    title as a whole. Notice that both the boxarts and interestingMoments lists are located at the same depth 
-    in the tree. Retrieve the time of the middle interesting moment and the smallest box art url simultaneously 
+    This is a variation of the problem we solved earlier. This time each video has an interesting moments
+    collection, each representing a time during which a screenshot is interesting or representative of the
+    title as a whole. Notice that both the boxarts and interestingMoments lists are located at the same depth
+    in the tree. Retrieve the time of the middle interesting moment and the smallest box art url simultaneously
     with zip(). Return an {id, title, time, url} JSON object for each video.
      */
     public static ComposableList<JSON> exercise23() {
@@ -1023,10 +1015,10 @@ public static ComposableList<JSON> exercise23() {
                             return smallest;
                         }
                     });
-                    
+
                     ComposableList<InterestingMoment> moment = video.interestingMoments.filter(m -> m.type == "Middle");
                     return ComposableListSolutions.zip(smallestBoxArt, moment, (s, m) -> {
-                        return json("id", video.id, "title", video.title, "time", m.time, "url", s.url);                        
+                        return json("id", video.id, "title", video.title, "time", m.time, "url", s.url);
                     });
                 });
             });
@@ -1052,7 +1044,7 @@ public static <T> ComposableListSolutions<T> of(T... args) {
         }
         return results;
     }
-    
+
     public static <T> ComposableListSolutions<T> of(List<T> list) {
         ComposableListSolutions<T> results = new ComposableListSolutions<T>();
         for (T value : list) {
diff --git a/src/main/java/learnrxjava/ObservableExercises.java b/src/main/java/learnrxjava/ObservableExercises.java
index a7c5d00..cb7248a 100644
--- a/src/main/java/learnrxjava/ObservableExercises.java
+++ b/src/main/java/learnrxjava/ObservableExercises.java
@@ -1,5 +1,6 @@
 package learnrxjava;
 
+import learnrxjava.types.BoxArt;
 import learnrxjava.types.JSON;
 import learnrxjava.types.Movies;
 import rx.Observable;
@@ -12,7 +13,8 @@ public class ObservableExercises {
      * @return "Hello World!"
      */
     public Observable<String> exerciseHello() {
-        return Observable.error(new RuntimeException("Not Implemented"));
+        //return Observable.error(new RuntimeException("Not Implemented"));
+        return Observable.just("Hello World!");
     }
 
     /**
@@ -21,7 +23,8 @@ public Observable<String> exerciseHello() {
      * @param "Hello Name!"
      */
     public Observable<String> exerciseMap(Observable<String> hello) {
-        return Observable.error(new RuntimeException("Not Implemented"));
+        //return Observable.error(new RuntimeException("Not Implemented"));
+        return Observable.just("Hello").map(n->n+" "+hello);
     }
 
     /**
@@ -32,7 +35,8 @@ public Observable<String> exerciseMap(Observable<String> hello) {
      * 6-Even
      */
     public Observable<String> exerciseFilterMap(Observable<Integer> nums) {
-        return Observable.error(new RuntimeException("Not Implemented"));
+        //return Observable.error(new RuntimeException("Not Implemented"));
+        return nums.filter(n->(n&1)==0).map(n->n.toString()+"-Even");
     }
 
     /**
@@ -42,7 +46,10 @@ public Observable<String> exerciseFilterMap(Observable<Integer> nums) {
      * @return Observable of Integers of Movies.videos.id
      */
     public Observable<Integer> exerciseConcatMap(Observable<Movies> movies) {
-        return Observable.error(new RuntimeException("Not Implemented"));
+        //return Observable.error(new RuntimeException("Not Implemented"));
+        return movies
+                .concatMap(m->m.videos)
+                .map(v->v.id);
     }
 
     /**
@@ -59,7 +66,8 @@ public Observable<Integer> exerciseConcatMap(Observable<Movies> movies) {
      * @return Observable of Integers of Movies.videos.id
      */
     public Observable<Integer> exerciseFlatMap(Observable<Movies> movies) {
-        return Observable.error(new RuntimeException("Not Implemented"));
+        //return Observable.error(new RuntimeException("Not Implemented"));
+        return movies.flatMap(m->m.videos.map(v->v.id));
     }
 
     /**
@@ -68,7 +76,8 @@ public Observable<Integer> exerciseFlatMap(Observable<Movies> movies) {
      * Use reduce to select the maximum value in a list of numbers.
      */
     public Observable<Integer> exerciseReduce(Observable<Integer> nums) {
-        return Observable.error(new RuntimeException("Not Implemented"));
+        //return Observable.error(new RuntimeException("Not Implemented"));
+        return nums.reduce((a,b)->a>b?a:b);
     }
 
     /**
@@ -83,9 +92,19 @@ public Observable<Integer> exerciseReduce(Observable<Integer> nums) {
      * See Exercise 19 of ComposableListExercises
      */
     public Observable<JSON> exerciseMovie(Observable<Movies> movies) {
-        return Observable.error(new RuntimeException("Not Implemented"));
+        //return Observable.error(new RuntimeException("Not Implemented"));
+
+        return movies.flatMap(m -> {
+            return m.videos.flatMap(v -> {
+                return v.boxarts.reduce((a, b) -> {
+                    if(a.width * a.height > b.width * b.height) return b;
+                    else return a;
+                }).map(maxBoxart->json("id", v.id, "title", v.title, "boxart", maxBoxart.url));
+            });
+        });
     }
 
+
     /**
      * Combine 2 streams into pairs using zip.
      * 
@@ -94,7 +113,8 @@ public Observable<JSON> exerciseMovie(Observable<Movies> movies) {
      * output -> "one fish", "two fish", "red fish", "blue fish"
      */
     public Observable<String> exerciseZip(Observable<String> a, Observable<String> b) {
-        return Observable.error(new RuntimeException("Not Implemented"));
+        return Observable.zip(a,b,(x,y)->x+" "+y);
+        //return Observable.error(new RuntimeException("Not Implemented"));
     }
 
     /**
@@ -102,7 +122,8 @@ public Observable<String> exerciseZip(Observable<String> a, Observable<String> b
      * and replace it with "default-value".
      */
     public Observable<String> handleError(Observable<String> data) {
-        return Observable.error(new RuntimeException("Not Implemented"));
+        //return Observable.error(new RuntimeException("Not Implemented"));
+        return data.onErrorResumeNext(Observable.just("default-value"));
     }
 
     /**
@@ -110,7 +131,9 @@ public Observable<String> handleError(Observable<String> data) {
      * with retry capability.
      */
     public Observable<String> retry(Observable<String> data) {
-        return Observable.error(new RuntimeException("Not Implemented"));
+        //return Observable.error(new RuntimeException("Not Implemented"));
+        return data.retry();
+
     }
 
     // This function can be used to build JSON objects within an expression