src/main/java/rocks/zipcode/io/quiz4/collections/ComparableTreeSet.java

@@ -1,17 +1,39 @@
 package rocks.zipcode.io.quiz4.collections;
 
+import java.util.TreeSet;
+
 /**
  * @author leon on 11/12/2018.
  */
-public class ComparableTreeSet<_> {
-    public ComparableTreeSet(_... arr) {
-    }
+public class ComparableTreeSet<Element> implements Comparable<Element> {
+    private TreeSet<Element> treeset = new TreeSet<Element>();
+
+    public ComparableTreeSet(Element... arr) {
+
+        for(Element itemAdded : arr){
+            treeset.add(itemAdded);
+        }
 
+    }
+    public int size(){
+        return treeset.size();
+    }
 
     public ComparableTreeSet() {
     }
 
-    public Integer compareTo(ComparableTreeSet<_> o) {
-        return null;
+    public Integer compareTo(ComparableTreeSet<Element> o) {
+        if (treeset.size() > o.size())
+          return 1;
+         else if (treeset.size() < o.size())
+           return -1;
+        else
+        return 0;
+        }
+
+
+    @Override
+    public int compareTo(Element o) {
+        return 0;
     }
 }

src/main/java/rocks/zipcode/io/quiz4/collections/SimpleStringGroup.java

@@ -1,31 +1,60 @@
 package rocks.zipcode.io.quiz4.collections;
 
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+
 /**
  * @author leon on 11/12/2018.
  */
-public class SimpleStringGroup {
+public class SimpleStringGroup implements Iterable {
+
+    private List<String> list = new ArrayList<String>();
+
+
     public SimpleStringGroup() {
-        throw new UnsupportedOperationException("Method not yet implemented");
+//        throw new UnsupportedOperationException("Method not yet implemented");
     }
 
     public Integer count() {
-        return null;
+        return list.size();
     }
 
     public void insert(String string) {
+        list.add(string);
     }
 
     public Boolean has(String valueToInsert) {
-        return null;
+        return list.contains(valueToInsert);
     }
 
     public String fetch(int indexOfValue) {
-        return null;
+        return list.get(indexOfValue);
     }
 
     public void delete(String valueToInsert) {
+        list.remove(valueToInsert);
     }
 
     public void clear() {
+        list.clear();
+    }
+
+    @Override
+    public Iterator iterator() {
+        return list.iterator();
+    }
+    @Override
+public void forEach(Consumer action) {
+        list.forEach(action);
+        }
+  @Override
+public Spliterator spliterator() {
+     return list.spliterator();
+
     }
+
+
 }

src/main/java/rocks/zipcode/io/quiz4/collections/ZipCodeWilmington.java

@@ -2,23 +2,44 @@ package rocks.zipcode.io.quiz4.collections;
 
 import rocks.zipcode.io.quiz4.objectorientation.Student;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 /**
  * @author leon on 11/12/2018.
  */
 public class ZipCodeWilmington {
+
+    private List<Student> students = new ArrayList<>();
+
+    public ZipCodeWilmington() {
+          this.students = new ArrayList<>();
+         }
+
     public void enroll(Student student) {
+        this.students.add(student);
     }
 
     public Boolean isEnrolled(Student student) {
-        return null;
+
+        return students.contains(student);
     }
 
     public void lecture(double numberOfHours) {
+        for (Student dork : this.students) {
+            dork.learn(numberOfHours);
+        }
     }
 
-    public Map<Student, Double> getStudyMap() {
-        return null;
+        public Map<Student, Double> getStudyMap () {
+
+            Map<Student, Double> map = new HashMap<>();
+            for (Student dork : this.students) {
+                map.put(dork, dork.getTotalStudyTime());
+            }
+            return map;
+        }
     }
-}
+

src/main/java/rocks/zipcode/io/quiz4/fundamentals/PalindromeEvaluator.java

@@ -1,18 +1,37 @@
 package rocks.zipcode.io.quiz4.fundamentals;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * @author leon on 18/12/2018.
  */
 public class PalindromeEvaluator {
+
+
     public static String[] getAllPalindromes(String string) {
-        return null;
+        List<String> result = new ArrayList<>();
+       for (int i = 0; i < string.length(); i++) {
+            for (int j = i + 1; j <= string.length(); j++) {
+                 if(isPalindrome(string.substring(i,j)) && !result.contains(string.substring(i,j))) {
+                    result.add(string.substring(i, j));
+                     }
+               }
+           }
+      return result.toArray(new String[0]);
     }
 
     public static Boolean isPalindrome(String string) {
-        return null;
+
+        return string.equals(reverseString(string));
     }
 
     public static String reverseString(String string) {
-        return null;
+
+        String newString = "";
+        for (int i = string.length() - 1; i >= 0 ; i--) {
+          newString += string.charAt(i);
+           }
+     return newString;
     }
 }

src/main/java/rocks/zipcode/io/quiz4/fundamentals/StringEvaluator.java

@@ -1,18 +1,42 @@
 package rocks.zipcode.io.quiz4.fundamentals;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
 /**
  * @author leon on 11/12/2018.
  */
 public class StringEvaluator {
     public static String[] getAllPrefixes(String string) {
-        return null;
+
+        ArrayList<String> list = new ArrayList<>();
+       for (int i = 0; i < string.length(); i++) {
+             for (int j = string.length(); j > i; j--) {
+                 if (!list.contains(string.substring(i, j))) {
+                    list.add(string.substring(i, j));
+                     }
+              }
+           }
+       return list.toArray(new String[list.size()]);
     }
 
     public static String[] getCommonPrefixes(String string1, String string2) {
-        return null;
+        List<String> result = new ArrayList<String>(Arrays.asList(getAllPrefixes(string1)));
+       result.retainAll(Arrays.asList(getAllPrefixes(string2)));
+       return result.toArray(new String[0]);
+
+
     }
 
     public static String getLargestCommonPrefix(String string1, String string2) {
-        return null;
+        String[] newArray = getCommonPrefixes(string1,string2);
+        String str = "";
+         for (String s : newArray) {
+            if (s.length() > str.length()) {
+               str = s;
+                }
+           }
+      return str;
     }
 }

src/main/java/rocks/zipcode/io/quiz4/generics/GenericUtils.java

@@ -8,11 +8,12 @@ import java.util.TreeSet;
  * @author leon on 11/12/2018.
  */
 public class GenericUtils {
-    public static <_ extends Comparable> Iterable<Iterable<_>> powerSet(Set<_> originalSet) {
+    public static <_ extends Comparable> Iterable<? extends Iterable<_>> powerSet(Set<_> originalSet) {
         return null;
     }
 
-    public static <_ extends Comparable> Iterable<Iterable<_>> powerSet(_... originalSet) {
+    public static <_ extends Comparable> Iterable<? extends Iterable<_>> powerSet(_... originalSet) {
         return powerSet(new TreeSet<>(Arrays.asList(originalSet)));
     }
 }
+

src/main/java/rocks/zipcode/io/quiz4/generics/Group.java

@@ -1,37 +1,45 @@
 package rocks.zipcode.io.quiz4.generics;
 
+import java.util.ArrayList;
 import java.util.Iterator;
+import java.util.List;
 
 /**
  * @author leon on 18/12/2018.
  */
-public class Group<_> {
+public class Group<_> implements Iterable<_>, GroupInterface<_> {
+    List<_> result = new ArrayList<>();
     public Group() {
-        throw new UnsupportedOperationException("Method not yet implemented");
+//        throw new UnsupportedOperationException("Method not yet implemented");
     }
 
+
     public Integer count() {
-        return null;
+        return result.size();
     }
 
     public void insert(_ value) {
+        result.add(value);
     }
 
     public Boolean has(_ value) {
-        return null;
+        return result.contains(value);
     }
 
     public _ fetch(int indexOfValue) {
-        return null;
+        return result.get(indexOfValue);
     }
 
     public void delete(_ value) {
+        result.remove(value);
     }
 
     public void clear() {
+        result.clear();
     }
 
     public Iterator<_> iterator() {
-        return null;
+        Iterator<_> list = result.iterator();
+        return list;
     }
 }

src/main/java/rocks/zipcode/io/quiz4/objectorientation/PalindromeObject.java

@@ -1,21 +1,41 @@
 package rocks.zipcode.io.quiz4.objectorientation;
 
+import rocks.zipcode.io.quiz4.fundamentals.PalindromeEvaluator;
+
+import java.util.HashSet;
+import java.util.Set;
+
 /**
  * @author leon on 18/12/2018.
  */
 public class PalindromeObject {
+
+    private String input;
     public PalindromeObject(String input) {
+        this.input = input;
     }
 
     public String[] getAllPalindromes(){
-        return null;
+
+        Set<String> list = new HashSet<>();
+        for (int i = 0; i < this.input.length(); i++){
+            for (int j = i + 1; j <= this.input.length(); j++){
+               if(PalindromeEvaluator.isPalindrome(this.input.substring(i, j))){
+                    list.add(this.input.substring(i, j));
+                    }
+                }
+           }
+
+       return list.toArray(new String[0]);
     }
 
     public Boolean isPalindrome(){
-        return null;
+
+        return (reverseString().equals(this.input));
     }
 
     public String reverseString(){
-        return null;
+
+        return new StringBuilder(this.input).reverse().toString();
     }
 }

src/main/java/rocks/zipcode/io/quiz4/objectorientation/StringAssembler.java

@@ -4,14 +4,22 @@ package rocks.zipcode.io.quiz4.objectorientation;
  * @author leon on 11/12/2018.
  */
 public class StringAssembler {
+    private Character delimeter;
+    private String fixer;
+
     public StringAssembler(Character delimeter) {
+        this.delimeter = delimeter;
+         this.fixer = "";
     }
 
     public StringAssembler append(String str) {
-        return null;
+
+        fixer += str + delimeter;
+        return this;
     }
 
     public String assemble() {
-        return null;
+
+        return fixer.substring(0, fixer.length() -1);
     }
 }

src/main/java/rocks/zipcode/io/quiz4/objectorientation/StringEvaluatorObject.java

@@ -1,21 +1,38 @@
 package rocks.zipcode.io.quiz4.objectorientation;
 
+import rocks.zipcode.io.quiz4.fundamentals.StringEvaluator;
+
+import java.util.HashSet;
+import java.util.Set;
+
 /**
  * @author leon on 19/12/2018.
  */
 public class StringEvaluatorObject {
+    private String str;
+
     public StringEvaluatorObject(String str) {
+        this.str = str;
     }
 
     public String[] getAllPrefixes() {
-        return null;
+
+        Set<String> results = new HashSet<>();
+        for (int i = 0; i < str.length(); i++){
+             for (int j = i + 1; j <= str.length(); j++){
+                 results.add(str.substring(i, j));
+                }
+          }
+      return results.toArray(new String[0]);
     }
 
     public String[] getCommonPrefixes(String secondInput) {
-        return null;
+
+        return StringEvaluator.getCommonPrefixes(str, secondInput);
     }
 
     public String getLargestCommonPrefix(String secondInput) {
-        return null;
+
+        return StringEvaluator.getLargestCommonPrefix(str, secondInput);
     }
 }

src/main/java/rocks/zipcode/io/quiz4/objectorientation/Student.java

@@ -4,17 +4,23 @@ package rocks.zipcode.io.quiz4.objectorientation;
  * @author leon on 11/12/2018.
  */
 public class Student {
+    private int id;
+    private double studyLength;
     public Student() {
-        this(null);
+
+        this(0);
     }
 
     public Student(Integer id) {
+        this.id = id;
     }
 
     public void learn(Double amountOfHours) {
+        studyLength += amountOfHours;
     }
 
     public Double getTotalStudyTime() {
-        return null;
+
+        return studyLength;
     }
 }

src/test/java/rocks/zipcode/io/quiz4/fundamentals/palindromeevaluator/PalindromeEvaluatorIsPalindromeTestNegative.java

@@ -25,6 +25,6 @@ public class PalindromeEvaluatorIsPalindromeTestNegative {
     }
 
     public void test(String input) {
-        Assert.assertTrue(PalindromeEvaluator.isPalindrome(input));
+        Assert.assertFalse(PalindromeEvaluator.isPalindrome(input));
     }
 }

src/test/java/rocks/zipcode/io/quiz4/objectorientation/palindromeobject/PalindromeObjectIsPalindromeTestNegative.java

@@ -25,6 +25,6 @@ public class PalindromeObjectIsPalindromeTestNegative {
     }
 
     public void test(String input) {
-        Assert.assertTrue(new PalindromeObject(input).isPalindrome());
+        Assert.assertFalse(new PalindromeObject(input).isPalindrome());
     }
 }

src/test/java/rocks/zipcode/io/quiz4/utils/MyTestClass.java

@@ -1,54 +0,0 @@
-package rocks.zipcode.io.quiz4.utils;
-
-import rocks.zipcode.io.quiz4.collections.ComparableTreeSet;
-
-import java.util.*;
-
-/**
- * @author leon on 18/12/2018.
- */
-public class MyTestClass {
-
-    public static <E> Set<Set<E>> findPowerSet(Set<E> set) {
-        Set<Set<E>> ret = new TreeSet<>();
-        ret.add(set);
-        if (set.isEmpty()) {
-            return ret;
-        }
-        Iterator<E> it = set.iterator();
-        while (it.hasNext()) {
-            Set<E> tmp = (Set)new ComparableTreeSet(set);   //create a copy of current set
-            tmp.remove(it.next());              //remove current element from copy set
-            ret.add(tmp);                       //add the remaining set to result
-            ret.addAll(findPowerSet(tmp));      //recursively find subsets of copy set
-        }
-        return ret;
-    }
-
-    public static void main(String[] args) {
-        Set<Character> set = (Set)new ComparableTreeSet<Character>();
-        set.add('x');
-        set.add('y');
-        set.add('z');
-        set.add('t');
-        System.out.println("Input set");
-        printSet(set);
-        System.out.println("\nsub sets");
-        findPowerSet(set).stream().forEach(MyTestClass::printSet);
-    }
-
-
-    public static <E> void printSet(E... val) {
-        printSet(new TreeSet<>(Arrays.asList(val)));
-    }
-
-    public static <E> void printSet(Set<E> set) {
-        StringBuilder sb = new StringBuilder(set.size() == 0 ? "{}\n" : "{");
-        Iterator<E> it = set.iterator();
-        while (it.hasNext()) {
-            sb.append(it.next().toString())
-                    .append(it.hasNext() ? ", " : "}\n");
-        }
-        System.out.print(sb.toString());
-    }
-}