diff --git a/src/main/java/learnrxjava/ComposableListExercises.java b/src/main/java/learnrxjava/ComposableListExercises.java
index a13940c..5ccf1c3 100644
--- a/src/main/java/learnrxjava/ComposableListExercises.java
+++ b/src/main/java/learnrxjava/ComposableListExercises.java
@@ -121,17 +121,9 @@ If our ComposableList had a map() method, it would make projections easier.
     public <R> ComposableList<R> map(Function<T, R> projectionFunction) {
         ComposableListExercises<R> results = new ComposableListExercises<R>();
         this.forEach(itemInList -> {
-            // ------------ INSERT CODE HERE! ----------------------------
-            // Apply the projectionFunction to each item in the list and add
-            // each result to the results list.
-            // 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;
     }
     
     /*
@@ -147,9 +139,7 @@ public static ComposableList<JSON> exercise5() {
             new Video(65432445, "The Chamber", 4.0),
             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));
     }
 
     /*
@@ -187,13 +177,13 @@ public static ComposableList<Video> exercise6() {
         ComposableListExercises<Video> highRatedVideos = new ComposableListExercises<Video>();
 
         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.0){
+            	highRatedVideos.add(video);
+            }
 
         });
         
-        // return highRatedVideos;
-        throw new UnsupportedOperationException("Not implemented yet.");        
+        return highRatedVideos;
     }
     
     /*
@@ -215,17 +205,12 @@ A Predicate is a test function that returns true or false (ex. x -> x > 1).
     public ComposableList<T> filter(Predicate<T> predicateFunction) {
         ComposableListExercises<T> results = new ComposableListExercises<T>();
         this.forEach(itemInList -> {
-            // ------------ INSERT CODE HERE! ----------------------------
-            // Apply the predicateFunction to each item in the list. If the
-            // result is true, add the result to the results list.
-            // 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 +249,8 @@ 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.0).map(video -> video.id);
 
-        throw new UnsupportedOperationException("Not implemented yet.");
     }
 
     /*
@@ -299,20 +283,22 @@ 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(movieList -> movieList.videos.forEach(movie -> {
+        	allVideoIdsInMovieLists.add(movie.id);
+        }));
         // ------------   INSERT CODE HERE!  -----------------------------------
-        //return allVideoIdsInMovieLists;
-        throw new UnsupportedOperationException("Not implemented yet.");
+        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 
+    To flatten trees with nested forEach expressions we accumulate 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 
+    function to each item in a list. However the projection function passed to concatMap transforms 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:
 
@@ -331,18 +317,20 @@ public <R> ComposableList<R> concatMap(
         Function<T, ComposableList<R>> projectionFunctionThatReturnsList) {
         ComposableListExercises<R> results = new ComposableListExercises<R>();
         for (T itemInList : this) {
-            // ------------ INSERT CODE HERE! ----------------------------
+            // ------------ INSERT CODE HERE! ---------------------------
+        	
             // Apply the projection function to each item in the list.
             // This will create _another_ list. Then loop through each
             // 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)
             // ------------ INSERT CODE HERE! ----------------------------
+        	projectionFunctionThatReturnsList.apply(itemInList).forEach(item -> {
+        		results.add(item);
+        	});
 
         }
         
-        //return results;
-        throw new UnsupportedOperationException("Not implemented yet.");
+        return results;
     }
     
     /*
@@ -372,11 +360,10 @@ 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 -> {
+        	return movieList.videos.map(video -> video.id);
+        });
         // **************ANSWER END***************//
-        throw new UnsupportedOperationException("Not implemented yet.");
     }
     
     /*
@@ -441,7 +428,7 @@ public static ComposableList<JSON> exercise12() {
             )
         );
 
-        // Use one or more map, concatAll, and filter calls to create an ComposableList with the following items
+        // Use one or more map, concatMap, and filter calls to create a ComposableList with the following items
         // {
         //   {"id": 70111470,"title": "Die Hard","boxart":"http://cdn-0.nflximg.com/images/2891/DieHard150.jpg" }
         //   {"id": 654356453,"title": "Bad Boys","boxart":"http://cdn-0.nflximg.com/images/2891/BadBoys150.jpg" },
@@ -449,8 +436,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(movieList ->{
+        	return  movieList.videos.concatMap(video -> {
+        		ComposableList<BoxArt> boxArts =  video.boxarts.filter(ba -> ba.width == 150 && ba.height == 200);
+        		return boxArts.map(boxArt -> json("id", video.id, "title", video.title, "boxart", boxArt.url));
+        	});
+        });
     }
 
     /*
@@ -484,13 +476,14 @@ public static BoxArt exercise13() {
                 currentSize = boxart.width * boxart.height;
                 if (currentSize > maxSize) {
                     // ****** INSERT CODE HERE ********
+                	maxSize = currentSize;
+                	largestBoxart = boxart;
                     // Assign the largestBoxart to the current boxart, and assign the maxSize to the currentSize.
                     // ****** INSERT CODE HERE ********
                 }
             }
 
-        // return largestBoxart;
-        throw new UnsupportedOperationException("Not implemented yet.");
+        return largestBoxart;
     }
     /*
     Exercise 14: Implement reduce()
@@ -518,7 +511,7 @@ public ComposableList<T> reduce(BiFunction<T, T, T> combiner) {
         // If the list is empty, return this
         if (this.size() == 0) {
             // ************ INSERT CODE HERE **************
-            //  if the list is empty, return this
+            return this;
             // ********************************************
         } else {
             accumulatedValue = this.get(0);
@@ -531,14 +524,12 @@ 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.");
     }
 
     /*
@@ -596,9 +587,12 @@ public static ComposableList<Integer> exercise16() {
         // returns a list with one item.
 
         // complete the expression below
-        //return ratings.reduce
+        return ratings.reduce((r1, r2)-> {
+        	if(r1 > r2) return r1;
+        	else return r2;
+        });
 
-        throw new UnsupportedOperationException("Not implemented yet.");
+        
     }
     /*
     Exercise 17: Retrieve url of the largest boxart
diff --git a/src/main/java/learnrxjava/ObservableExercises.java b/src/main/java/learnrxjava/ObservableExercises.java
index a7c5d00..d4a803e 100644
--- a/src/main/java/learnrxjava/ObservableExercises.java
+++ b/src/main/java/learnrxjava/ObservableExercises.java
@@ -12,7 +12,7 @@ public class ObservableExercises {
      * @return "Hello World!"
      */
     public Observable<String> exerciseHello() {
-        return Observable.error(new RuntimeException("Not Implemented"));
+        return Observable.just("Hello World!");
     }
 
     /**
@@ -21,7 +21,7 @@ public Observable<String> exerciseHello() {
      * @param "Hello Name!"
      */
     public Observable<String> exerciseMap(Observable<String> hello) {
-        return Observable.error(new RuntimeException("Not Implemented"));
+        return hello.map(string -> string + " Name");
     }
 
     /**
@@ -32,7 +32,7 @@ public Observable<String> exerciseMap(Observable<String> hello) {
      * 6-Even
      */
     public Observable<String> exerciseFilterMap(Observable<Integer> nums) {
-        return Observable.error(new RuntimeException("Not Implemented"));
+        return nums.filter(num -> num % 2 == 0).map(num -> num + "-Even");
     }
 
     /**
@@ -42,7 +42,7 @@ 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 movies.concatMap(movie -> movie.videos.map(v -> v.id));
     }
 
     /**
@@ -59,7 +59,7 @@ 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 movies.flatMap(movie -> movie.videos.map(video -> video.id));
     }
 
     /**
@@ -68,7 +68,10 @@ 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 nums.reduce((i, i1) -> {
+        	if(i>i1) return i;
+        	else return i1;
+        });
     }
 
     /**