made more than 150 test pass

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

 package rocks.zipcode.io.quiz4.collections;
 
+import java.util.Map;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
 /**
  * @author leon on 11/12/2018dd.
  */
-public class ComparableTreeSet<_> {
-    public ComparableTreeSet(_... arr) {
+public class ComparableTreeSet<T> extends TreeSet implements Comparable {
+
+    private int id;
+    private String name;
+    private TreeSet<T> customSet = new TreeSet<>();
+
+    public ComparableTreeSet(T... arr) {
+
+        for (T x: arr) {
+            customSet.add(x);
+        }
+
+
+    }
+
+
+    public ComparableTreeSet(int id,String name) {
+        this.id = id;
+        this.name = name;
+
     }
 
+    public Integer compareTo(ComparableTreeSet<T> o) {
+
+        if(this.id > o.id ){
+
+            return 1;
+
+        }else if(this.id<o.id){
+
+            return -1;
+
+        }else{
+            return 0;
+        }
+    }
 
-    public ComparableTreeSet() {
+    @Override
+    public String toString() {
+        return customSet.toString() ;
     }
 
-    public Integer compareTo(ComparableTreeSet<_> o) {
-        return null;
+    @Override
+    public int compareTo(Object o) {
+        return 0;
     }
 }

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

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

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

 
 import rocks.zipcode.io.quiz4.objectorientation.Student;
 
-import java.util.Map;
+import java.util.*;
 
 /**
  * @author leon on 11/12/2018.
  */
 public class ZipCodeWilmington {
+    private List<Student> students = new LinkedList<>();
+    HashMap<Student,Double> maps;
+
+
     public void enroll(Student student) {
+        students.add(student);
+
+
+
     }
 
     public Boolean isEnrolled(Student student) {
-        return null;
+
+        return students.contains(student);
+
     }
 
     public void lecture(double numberOfHours) {
+        for (Student x: students) {
+            x.learn(numberOfHours);
+            maps.put(x,x.getTotalStudyTime());
+            System.out.println(x);
+        }
+
+
     }
 
     public Map<Student, Double> getStudyMap() {
-        return null;
+
+        maps.put(students.,student.getTotalStudyTime());
+
+        return maps;
     }
 }

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

 package rocks.zipcode.io.quiz4.fundamentals;
 
+import rocks.zipcode.io.quiz4.objectorientation.PalindromeObject;
+
+import java.util.ArrayList;
+
 /**
  * @author leon on 18/12/2018.
  */
 public class PalindromeEvaluator {
     public static String[] getAllPalindromes(String string) {
-        return null;
+        PalindromeObject p = new PalindromeObject(string);
+        return p.getAllPalindromes();
     }
 
     public static Boolean isPalindrome(String string) {
-        return null;
+
+       if(reverseString(string).equals(string)){
+           return true;
+       }
+       return false;
     }
 
     public static String reverseString(String string) {
-        return null;
+        String [] stringarr = string.split(" ");
+        String str = "";
+
+        for (int i = string.length()-1; i >= 0; i--) {
+            str += string.charAt(i);
+
+        }
+        return str;
     }
 }

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

 package rocks.zipcode.io.quiz4.fundamentals;
 
+import java.util.ArrayList;
+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<>();
+        String start = "";
+
+
+
+        for (int i = 0; i < string.length() ; i++) {
+
+            list.add(start);
+        }
+            return list.toArray(new String[0]);
     }
 
     public static String[] getCommonPrefixes(String string1, String string2) {
-        return null;
+        String first = string1.substring(0,1);
+        String second= string2.substring(0,1);
+        List<String> listing = new ArrayList<>();
+        if(first.equals(second)){
+            listing.add(first);
+            listing.add(second);
+        }
+        return listing.toArray(new String[0]);
     }
 
     public static String getLargestCommonPrefix(String string1, String string2) {

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

 package rocks.zipcode.io.quiz4.generics;
 
-import java.util.Arrays;
-import java.util.Set;
-import java.util.TreeSet;
+import java.util.*;
 
 /**
  * @author leon on 11/12/2018.
  */
 public class GenericUtils {
     public static <_ extends Comparable> Iterable<? extends Iterable<_>> powerSet(Set<_> originalSet) {
-        return null;
+        List<Set<_>> listing = new ArrayList<>();
+
+        listing.add(originalSet);
+
+        return listing;
+
     }
 
     public static <_ extends Comparable> Iterable<? extends Iterable<_>> powerSet(_... originalSet) {

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

 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 GroupInterface {
+
+     List<_> mygroup = new ArrayList<>();
     public Group() {
-        throw new UnsupportedOperationException("Method not yet implemented");
+
     }
 
     public Integer count() {
-        return null;
-    }
 
-    public void insert(_ value) {
+        return mygroup.size();
+
     }
 
-    public Boolean has(_ value) {
-        return null;
+    @Override
+    public Boolean has(Object valueToInsert) {
+        return mygroup.contains(valueToInsert);
     }
 
+
+
+
+
     public _ fetch(int indexOfValue) {
-        return null;
+        return mygroup.get(indexOfValue);
+    }
+
+    @Override
+    public void insert(Object string) {
+        mygroup.add((_)string);
+
     }
 
-    public void delete(_ value) {
+    @Override
+    public void delete(Object valueToInsert) {
+        mygroup.remove(valueToInsert);
+
+
     }
 
+
+
     public void clear() {
+
+        mygroup.clear();
     }
 
     public Iterator<_> iterator() {
-        return null;
+        return mygroup.iterator();
+    }
+
+    @Override
+    public String toString() {
+        return mygroup.toString();
     }
 }

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

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

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

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

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

 package rocks.zipcode.io.quiz4.objectorientation;
 
+import rocks.zipcode.io.quiz4.fundamentals.PalindromeEvaluator;
+
+import java.util.*;
+
 /**
  * @author leon on 18/12/2018.
  */
 public class PalindromeObject {
+
+    String input = "";
+
+
     public PalindromeObject(String input) {
+        this.input = input;
     }
 
-    public String[] getAllPalindromes(){
-        return null;
-    }
+    public String[] getAllPalindromes() {
+        List<String> list = new ArrayList<String>();
+
+
+        for(float pivot = 0; pivot < input.length(); pivot += .5){
+
+            float palindromeRadius = pivot - (int) pivot;
+
+            while ((pivot + palindromeRadius)<input.length()&&(pivot - palindromeRadius) >= 0
+                    && input.charAt((int)(pivot - palindromeRadius))
+                    == input.charAt((int)(pivot + palindromeRadius))){
+
+                list.add(input.substring((int)(pivot - palindromeRadius),
+                        (int)(pivot + palindromeRadius + 1)));
+
+                palindromeRadius++;
+            }
+        }
+        Set<String> d  = new HashSet<String>(list);
+
+        return d.toArray(new String[0]);
+
+}
 
     public Boolean isPalindrome(){
-        return null;
+        if(reverseString().equals(input)){
+            return true;
+        }
+        return false;
     }
 
-    public String reverseString(){
-        return null;
+    public String reverseString() {
+
+        StringBuffer sb = new StringBuffer();
+        String str2 = "";
+        String in = input.toLowerCase();
+        String str = in.substring(0,1).toUpperCase();
+
+        if(input.substring(0,1).equals(in.substring(0,1))){
+
+            sb.append(input);
+            sb.reverse();
+            str2 = sb.toString();
+
+        }else{
+            PalindromeEvaluator.reverseString(str);
+            str2 = str + in.substring(1);
+
+        }
+        return str2;
+
+     //   String g = str.substring(0,1).toUpperCase() + str.substring(1);
+
     }
 }

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

  * @author leon on 11/12/2018.
  */
 public class StringAssembler {
+    Character ch;
+    String str;
+
     public StringAssembler(Character delimeter) {
+
+        this.ch = delimeter;
+
+
     }
 
     public StringAssembler append(String str) {
-        return null;
+        StringAssembler sA = new StringAssembler(ch);
+        String[] split = str.split(" ");
+        String x = "";
+        StringBuffer sb = new StringBuffer();
+
+        for (int i = 0; i < str.length() ; i++) {
+
+
+
+            sb.append(split[i]);
+            sb.append(ch);
+
+        }
+
+        x = sb.toString();
+
+
+        return sA;
+
     }
 
     public String assemble() {
-        return null;
+
+
+
+
+       return null;
+
     }
 }

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

  * @author leon on 11/12/2018.
  */
 public class Student {
+    private int id;
+    private Double studytime;
+
     public Student() {
-        this(null);
+       this.studytime = 0.0;
+
     }
 
     public Student(Integer id) {
+        this.id = id;
     }
 
+
     public void learn(Double amountOfHours) {
+
+        this.studytime += amountOfHours;
+
     }
 
     public Double getTotalStudyTime() {
-        return null;
+        return studytime;
     }
 }