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

 package rocks.zipcode.io.quiz4.collections;
 
+import java.util.Arrays;
+import java.util.TreeSet;
+
 /**
  * @author leon on 11/12/2018.
  */
-public class ComparableTreeSet<_> {
+public class ComparableTreeSet<_> extends TreeSet implements Comparable {
+    _[] array;
+
     public ComparableTreeSet(_... arr) {
+//        TreeSet<_> treeSet = new TreeSet<>();
+//        for (_ generic : arr) {
+//            treeSet.add(generic);
+//        }
+//
+//        for (_ branch : treeSet) {
+//            System.out.println(branch);
+//        }
+
+        TreeSet<_> treeSet = new TreeSet<_>(Arrays.asList(arr));
+        treeSet.toString();
+//        array = (_[]) treeSet.toArray();
     }
 
 
     public ComparableTreeSet() {
     }
 
-    public Integer compareTo(ComparableTreeSet<_> o) {
-        return null;
+//    public Integer compareTo(ComparableTreeSet<_> o) {
+//        return null;
+//    }
+
+    @Override
+    public int compareTo(Object o) {
+        for (int i = 0; i < array.length; i++) {
+            if (array[i].hashCode() > o.hashCode()) {
+                return 1;
+            } else {
+                return -1;
+            }
+        }
+        return 0;
+    }
+
+    @Override
+    public String toString() {
+        return super.toString();
     }
-}
+}

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

 package rocks.zipcode.io.quiz4.fundamentals;
 
+import java.util.TreeSet;
+
 /**
  * @author leon on 18/12/2018.
  */
 public class PalindromeEvaluator {
     public static String[] getAllPalindromes(String string) {
-        return null;
+        TreeSet<String> treeSet = new TreeSet<>();
+        for (int i = 0; i < string.length(); i++) {
+            treeSet.add(String.valueOf(string.charAt(i)));
+        }
+
+        for (int i = 0; i < string.length() / 2; i++) {
+            if(string.charAt(i) == string.charAt(string.length() - 1 - i)) {
+                treeSet.add(string.substring(i, string.length() - i));
+            }
+        }
+        return treeSet.toArray(new String[0]);
     }
 
     public static Boolean isPalindrome(String string) {
-        return null;
+        for (int i = 0; i < string.length() - 1; i++) {
+            if (string.charAt(i) != string.charAt(string.length() - 1 - i)) {
+                return false;
+            }
+        }
+        return true;
     }
 
     public static String reverseString(String string) {
-        return null;
+        String[] reversedString = new String[string.length()];
+        StringBuilder sb = new StringBuilder(string.length());
+        for (int i = string.length() - 1, j = 0; i >= 0; i--, j++) {
+            sb.append(string.charAt(i));
+        }
+        return sb.toString();
     }
 }

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

 package rocks.zipcode.io.quiz4.fundamentals;
 
+import java.util.TreeSet;
+
 /**
  * @author leon on 11/12/2018.
  */
 public class StringEvaluator {
     public static String[] getAllPrefixes(String string) {
-        return null;
+        TreeSet<String> treeSet = new TreeSet<>();
+        for (int i = 0, j = string.length(); i < string.length(); i++, j--) {
+//            treeSet.add(String.valueOf(string.charAt(i)));
+//            System.out.println(string.charAt(i));
+//            treeSet.add(string.substring(i));
+//            System.out.println(string.substring(i));
+//            if (i > 1) {
+//                treeSet.add(string.substring(0, i));
+//                System.out.println(string.substring(0, i));
+//            }
+//            if (j > i) {
+//                treeSet.add(string.substring(i, j));
+//                System.out.println(string.substring(i, j));
+//            }
+            treeSet.add(String.valueOf(string.charAt(i)));
+            treeSet.add(string.substring(i));
+            if (i > 0 && j > 1) {
+                treeSet.add(string.substring(1, j));
+            }
+            if (j > i) {
+                treeSet.add(string.substring(i, j));
+                System.out.println(string.substring(i, j));
+            }
+            if (j > 0) {
+                treeSet.add(string.substring(0, j));
+                System.out.println(string.substring(0, j));
+            }
+        }
+
+        return treeSet.toArray(new String[0]);
     }
 
     public static String[] getCommonPrefixes(String string1, String string2) {

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

  */
 public class Group<_> {
     public Group() {
-        throw new UnsupportedOperationException("Method not yet implemented");
+//        throw new UnsupportedOperationException("Method not yet implemented");
     }
 
     public Integer count() {

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

 package rocks.zipcode.io.quiz4.generics;
 
+import java.util.Iterator;
+import java.util.Stack;
+
 /**
  * @author leon on 11/12/2018.
  */
-public class MyStack<SomeType> {
+public class MyStack<SomeType> implements Iterable {
+    Stack<SomeType> someTypeStack = new Stack<>();
+
     public MyStack() {
-        throw new UnsupportedOperationException("Method not yet implemented");
+
     }
 
     public Boolean isEmpty() {
-        return null;
+        return someTypeStack.empty();
     }
 
     public void push(SomeType i) {
+        someTypeStack.push(i);
     }
 
     public SomeType peek() {
-        throw new UnsupportedOperationException("Method not yet implemented");
+        return someTypeStack.peek();
     }
 
     public SomeType pop() {
+        return someTypeStack.pop();
+    }
+
+    @Override
+    public Iterator iterator() {
         return null;
     }
 }

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

 /**
  * @author leon on 18/12/2018.
  */
-public class SortedGroup<_> extends Group<_> {
+public class SortedGroup<_> extends Group<_> implements GroupInterface {
+//    @Override
+//    public void insert(_ value) {
+//    }
+//
+//    @Override
+//    public void delete(_ value) {
+//    }
+
+    public Integer indexOf(_ firstValue) {
+        return null;
+    }
+
     @Override
-    public void insert(_ value) {
+    public Boolean has(Object valueToInsert) {
+        return null;
     }
 
     @Override
-    public void delete(_ value) {
+    public void insert(Object string) {
+
     }
 
-    public Integer indexOf(_ firstValue) {
-        return null;
+    @Override
+    public void delete(Object valueToInsert) {
+
     }
 }