done

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

@@ -1,17 +1,33 @@
 package rocks.zipcode.io.quiz4.collections;
 
+import java.util.Arrays;
+import java.util.TreeSet;
+
 /**
  * @author leon on 11/12/2018.
  */
-public class ComparableTreeSet<_> {
-    public ComparableTreeSet(_... arr) {
+public class ComparableTreeSet<T> extends TreeSet implements Comparable {
+
+
+    public ComparableTreeSet(T... arr) {
+        for(T elem: arr)
+
+        this.add(elem);
     }
 
 
     public ComparableTreeSet() {
     }
 
-    public Integer compareTo(ComparableTreeSet<_> o) {
-        return null;
+
+    @Override
+    public int compareTo(Object o) {
+
+        String st1=this.toString();
+        String st2= o.toString();
+
+        return st1.compareTo(st2);
     }
+
+
 }

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

@@ -1,31 +1,63 @@
 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{
+
+    List<String> list= new ArrayList<>();
+
     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 null;
+    }
+
+    @Override
+    public void forEach(Consumer action) {
+
+    }
+
+    @Override
+    public Spliterator spliterator() {
+        return null;
     }
 }

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

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

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

@@ -1,28 +1,45 @@
 package rocks.zipcode.io.quiz4.fundamentals;
 
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
 /**
  * @author leon on 18/12/2018.
  */
 public class PalindromeEvaluator {
     public static String[] getAllPalindromes(String string) {
-        return null;
+
+        Set<CharSequence> out = new HashSet<CharSequence>();
+        int length = string.length();
+        for (int i = 1; i <= length; i++) {
+            for (int j = i - 1, k = i; j >= 0 && k < length; j--, k++) {
+                if (string.charAt(j) == string.charAt(k)) {
+                    out.add(string.subSequence(j, k + 1));
+                } else {
+                    break;
+                }
+            }
+        }
+        return out.toArray(new String[0]);
+
+
     }
 
+
+
     public static Boolean isPalindrome(String string) {
 
-        char[] newString= new char[string.length()];
-        int i1 = 0;
-        int i2 = newString.length - 1;
-        while (i2 > i1) {
-            if (newString[i1] != newString[i2]) {
+
+        for(int i=0;i<=string.length()/2;i++)
+            if(string.charAt(i)!=string.charAt(string.length()-1-i))
                 return false;
-            }
-            ++i1;
-            --i2;
-        }
         return true;
 
 
+
+
+
     }
 
     public static String reverseString(String string) {

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

@@ -1,18 +1,47 @@
 package rocks.zipcode.io.quiz4.fundamentals;
 
+import com.sun.xml.internal.ws.util.StringUtils;
+
 /**
  * @author leon on 11/12/2018.
  */
 public class StringEvaluator {
     public static String[] getAllPrefixes(String string) {
+
         return null;
     }
 
     public static String[] getCommonPrefixes(String string1, String string2) {
-        return null;
+
+          return null;
+
     }
 
     public static String getLargestCommonPrefix(String string1, String string2) {
-        return null;
+
+
+        int minStrLen = string1.length();
+        if ( minStrLen > string2.length()){
+            minStrLen = string2.length();
+        }
+
+        StringBuilder output = new StringBuilder();
+        for(int i=0; i<minStrLen; i++){
+            if ( string1.charAt(i) ==  string2.charAt(i)){
+                output.append(string1.charAt(i));
+            }else{
+                break;
+            }
+        }
+       return (output.toString());
+
+//        int minLength = Math.min(string1.length(), string2.length());
+//        for (int i = 0; i < minLength; i++) {
+//            if (string1.charAt(i) != string2.charAt(i)) {
+//                return string1.substring(0, i);
+//            }
+//        }
+//        return string1.substring(0, minLength);
+
     }
 }

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

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

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

@@ -1,37 +1,54 @@
 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<T>  implements GroupInterface<T> {
+
+    List<T> list= new ArrayList<>();
     public Group() {
-        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(_ value) {
+    public void insert(T value) {
+        list.add(value);
     }
 
-    public Boolean has(_ value) {
-        return null;
+    public Boolean has(T value) {
+        return list.contains(value);
     }
 
-    public _ fetch(int indexOfValue) {
-        return null;
+    public T fetch(int indexOfValue) {
+        return list.get(indexOfValue);
     }
 
-    public void delete(_ value) {
+    public void delete(T value) {
+        list.remove(value);
     }
 
     public void clear() {
+        list.clear();
+    }
+
+    public Iterator<T> iterator() {
+
+        Iterator<T> iterator= list.iterator();
+        while (iterator.hasNext()) {
+            iterator.next();
+        }
+        return iterator;
     }
 
-    public Iterator<_> iterator() {
-        return null;
+    @Override
+    public String toString() {
+        return String.valueOf(list);
     }
 }

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

@@ -3,11 +3,11 @@ package rocks.zipcode.io.quiz4.generics;
 /**
  * @author leon on 18/12/2018.
  */
-public interface GroupInterface<_> extends Iterable<_> {
+public interface GroupInterface<T> extends Iterable<T> {
     Integer count();
-    Boolean has(_ valueToInsert);
-    _ fetch(int indexOfValue);
-    void insert(_ string);
-    void delete(_ valueToInsert);
+    Boolean has(T valueToInsert);
+    T fetch(int indexOfValue);
+    void insert(T string);
+    void delete(T valueToInsert);
     void clear();
 }

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

@@ -1,25 +1,51 @@
 package rocks.zipcode.io.quiz4.generics;
 
+import java.util.*;
+import java.util.function.Consumer;
+
 /**
  * @author leon on 11/12/2018.
  */
-public class MyStack<SomeType> {
+public class MyStack<SomeType> implements Iterable<SomeType> {
+
+    Stack stack = new Stack();
+
     public MyStack() {
-        throw new UnsupportedOperationException("Method not yet implemented");
+       // throw new UnsupportedOperationException("Method not yet implemented");
     }
 
     public Boolean isEmpty() {
-        return null;
+
+        return stack.isEmpty();
     }
 
     public void push(SomeType i) {
+        stack.addElement(i);
     }
 
-    public SomeType peek() {
-        throw new UnsupportedOperationException("Method not yet implemented");
+    public SomeType peek() throws EmptyStackException{
+
+       // throw new UnsupportedOperationException("Method not yet implemented");
+        return (SomeType) stack.peek();
     }
 
     public SomeType pop() {
+      return (SomeType) stack.pop();
+
+    }
+
+    @Override
+    public Iterator<SomeType> iterator() {
+        return null;
+    }
+
+    @Override
+    public void forEach(Consumer<? super SomeType> action) {
+
+    }
+
+    @Override
+    public Spliterator<SomeType> spliterator() {
         return null;
     }
 }

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

@@ -1,18 +1,31 @@
 package rocks.zipcode.io.quiz4.generics;
 
+import java.util.*;
+
 /**
  * @author leon on 18/12/2018.
  */
-public class SortedGroup<_> extends Group<_> {
+public class SortedGroup<T> extends Group<T> {
+
+
     @Override
-    public void insert(_ value) {
+    public void insert(T value) {
+
+        list.add(value);
+        Collections.sort(list,null);
     }
 
     @Override
-    public void delete(_ value) {
+    public void delete(T value) {
+       list.remove(value);
+        Collections.sort(list,null);
     }
 
-    public Integer indexOf(_ firstValue) {
-        return null;
+    public Integer indexOf(T firstValue) {
+
+        Collections.sort(list,null);
+       return list.indexOf(firstValue);
+
+
     }
 }

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

@@ -1,10 +1,15 @@
 package rocks.zipcode.io.quiz4.objectorientation;
 
+import rocks.zipcode.io.quiz4.fundamentals.PalindromeEvaluator;
+
 /**
  * @author leon on 18/12/2018.
  */
 public class PalindromeObject {
+    private final String input;
+
     public PalindromeObject(String input) {
+        this.input= input;
     }
 
     public String[] getAllPalindromes(){
@@ -12,10 +17,10 @@ public class PalindromeObject {
     }
 
     public Boolean isPalindrome(){
-        return null;
+        return PalindromeEvaluator.isPalindrome(input);
     }
 
     public String reverseString(){
-        return null;
+        return PalindromeEvaluator.reverseString(input);
     }
 }

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

@@ -1,17 +1,28 @@
 package rocks.zipcode.io.quiz4.objectorientation;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * @author leon on 11/12/2018.
  */
 public class StringAssembler {
+
+    List<String> list= new ArrayList<>();
+    private  String delimeter;
+
     public StringAssembler(Character delimeter) {
+        this.delimeter= ""+ delimeter;
     }
 
     public StringAssembler append(String str) {
-        return null;
+        list.add(str);
+        return this;
+
     }
 
     public String assemble() {
-        return null;
+
+        return String.join(delimeter, list);
     }
 }

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

@@ -1,21 +1,27 @@
 package rocks.zipcode.io.quiz4.objectorientation;
 
+import rocks.zipcode.io.quiz4.fundamentals.StringEvaluator;
+
 /**
  * @author leon on 19/12/2018.
  */
 public class StringEvaluatorObject {
+    private final String str;
+
     public StringEvaluatorObject(String str) {
+        this.str= str;
     }
 
-    public String[] getAllPrefixes() {
-        return null;
+    public String[] getAllPrefixes()
+    {
+        return StringEvaluator.getAllPrefixes(str);
     }
 
     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,24 @@ package rocks.zipcode.io.quiz4.objectorientation;
  * @author leon on 11/12/2018.
  */
 public class Student {
+    private  Integer id;
+    private Double totalStudyTime=0.0;
+
     public Student() {
-        this(null);
+
     }
 
     public Student(Integer id) {
+        this.id=id;
     }
 
     public void learn(Double amountOfHours) {
+        totalStudyTime += amountOfHours;
+
     }
 
     public Double getTotalStudyTime() {
-        return null;
+
+        return totalStudyTime;
     }
 }