Almost

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

@@ -4,14 +4,30 @@ package rocks.zipcode.io.quiz4.collections;
  * @author leon on 11/12/2018.
  */
 public class ComparableTreeSet<T> {
+    private T value;
+
     public ComparableTreeSet(T... arr) {
     }
 
+    public ComparableTreeSet(T value) {
+        this.value = value;
+    }
 
     public ComparableTreeSet() {
     }
 
     public Integer compareTo(ComparableTreeSet<T> o) {
-        return null;
+        return getValue().compareTo(o.getValue());
+    }
+
+    private ComparableTreeSet<T> getValue() {
+        return (ComparableTreeSet<T>) value;
+    }
+
+    @Override
+    public String toString() {
+        return "ComparableTreeSet{" +
+                "value=" + value +
+                '}';
     }
 }

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

@@ -1,24 +1,32 @@
 package rocks.zipcode.io.quiz4.collections;
 
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.Set;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+
+import static com.sun.jmx.snmp.ThreadContext.contains;
 
 /**
  * @author leon on 11/12/2018.
  */
-public class SimpleStringGroup {
+public class SimpleStringGroup implements Iterable{
     public SimpleStringGroup() {
-        throw new UnsupportedOperationException("Method not yet implemented");
+        //throw new UnsupportedOperationException("Method not yet implemented");
     }
 
-    Set<String> set = new HashSet<String>();
+    private final Set<String> set = new HashSet<>();
+
 
     public Integer count() {
         return set.size();
     }
 
     public void insert(String string) {
-        set.add(string);
+        if (!contains(string)) {
+            set.add(string);
+        }
     }
 
     public Boolean has(String valueToInsert) {
@@ -26,7 +34,9 @@ public class SimpleStringGroup {
     }
 
     public String fetch(int indexOfValue) {
-        return null;
+        //return set.add(indexOfValue);
+        return String.valueOf(set.equals(indexOfValue));
+        //return null;
     }
 
     public void delete(String valueToInsert) {
@@ -36,4 +46,22 @@ public class SimpleStringGroup {
     public void clear() {
         set.clear();
     }
+
+   public void get() {
+        set.size();
+   }
+
+    @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

@@ -7,10 +7,13 @@ import java.util.Map;
 /**
  * @author leon on 11/12/2018.
  */
-public class ZipCodeWilmington {
+public class ZipCodeWilmington extends Student{
+    private double numberOfHours;
+
     Map<Student, Double> stud = new HashMap<>();
+
     public void enroll(Student student) {
-        stud.put(student,1.0);
+        stud.put(student,0.0);
     }
 
     public Boolean isEnrolled(Student student) {
@@ -18,7 +21,7 @@ public class ZipCodeWilmington {
     }
 
     public void lecture(double numberOfHours) {
-        stud.get(numberOfHours);
+            learn(numberOfHours);
     }
 
     public Map<Student, Double> getStudyMap() {

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

@@ -42,7 +42,7 @@ public class PalindromeEvaluator {
         string = string.substring(1, string.length() - 1);
         // Put all obtained palindromes in a hash map to
         // find only distinct palindromess
-        m.put(string.substring(0, 1), 1);
+       // m.put(string.substring(0, 1), 1);
         for (int i = 1; i < n; i++) {
             for (int j = 0; j <= 1; j++)
                 for (int rp = R[j][i]; rp > 0; rp--)
@@ -52,9 +52,6 @@ public class PalindromeEvaluator {
         }
         // printing all distinct palindromes from
         // hash map
-//        for (Map.Entry<String, Integer> ii : m.entrySet()) {
-//            System.out.println(ii.getKey());
-//        }
        return new String[]{m.toString()};
 
     }

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

@@ -1,35 +1,61 @@
 package rocks.zipcode.io.quiz4.fundamentals;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.lang.String;
+
 /**
  * @author leon on 11/12/2018.
  */
 public class StringEvaluator {
     public static String[] getAllPrefixes(String string) {
-        String[] output = new String[string.length()];
-        for (int index = 0; index < string.length(); index++) {
-            //output[index] = "" + string + string[index];
-            output[index] = "" + string ;
-        }
-        return output;
+        List<String> numbers = Arrays.asList(string);
+
+        String joinedString =  numbers
+                .stream()
+                .collect(Collectors.joining(", ","",""));
+        return new String[]{joinedString};
 
     }
 
-    public static String[] getCommonPrefixes(String string1, String string2) {
-        String[] str = new String[string1.length() + string2.length()];
-        int i = 0;
-        for(String s: str)
-        if(string1.equals(string2)) {
-            str[i] += string1;
-        }
-        return str;
+   public static String[] getCommonPrefixes(String string1, String string2) {
+//        int i = 0;
+//        if (string1 == null || string2 == null || string1.length() == 0 || string2.length() == 0) {
+//            return new String[]{""};
+//        }
+//        while (i < string1.length() && i < string2.length() && string1.charAt(i) == string2.charAt(i)) {
+//            i++;
+//        }
+//        return new String[]{string1.substring(0, i)};
+
+//       return getCommonPrefixes( string1, string2);
+
+
+       String result = "";
+       int n1 = string1.length(), n2 = string2.length();
+
+       // Compare str1 and str2
+       for (int i = 0, j = 0; i <= n1 - 1 && j <= n2 - 1; i++, j++) {
+           if (string1.charAt(i) != string2.charAt(j)) {
+               break;
+           }
+           result += string1.charAt(i);
+       }
+
+       return new String[]{(result)};
+
     }
 
     public static String getLargestCommonPrefix(String string1, String string2) {
-        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);
+//        if (strs.length == 0) return "";
+//        String prefix = strs[0];
+//        for (int i = 1; i < strs.length; i++)
+//            while (strs[i].indexOf(prefix) != 0) {
+//                prefix = prefix.substring(0, prefix.length() - 1);
+//                if (prefix.isEmpty()) return "";
+//            }
+//        return prefix;
+        return null;
     }
 }

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<? extends Iterable<_>> powerSet(Set<_> originalSet) {
+    public static <T extends Comparable> Iterable<? extends Iterable<T>> powerSet(Set<T> originalSet) {
         return null;
     }
 
-    public static <_ extends Comparable> Iterable<? extends Iterable<_>> powerSet(_... originalSet) {
+    public static <T extends Comparable> Iterable<? extends Iterable<T>> powerSet(T... originalSet) {
         return powerSet(new TreeSet<>(Arrays.asList(originalSet)));
     }
 }

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

@@ -1,56 +1,65 @@
 package rocks.zipcode.io.quiz4.generics;
 
+import java.util.ArrayList;
 import java.util.Iterator;
+import java.util.List;
+import java.util.Spliterator;
+import java.util.function.Consumer;
 
 /**
  * @author leon on 18/12/2018.
  */
-public class Group<T> {
+public class Group<T> implements Iterable<T>{
     public Group() {
-        throw new UnsupportedOperationException("Method not yet implemented");
+        //throw new UnsupportedOperationException("Method not yet implemented");
     }
 
-    //Set<T> set;
-    private Group<T> group ;
+    List<T> list = new ArrayList<>();
 
-    public Group(Group<T> group) {
-        this.group = group;
-    }
 
     public Integer count() {
-       return group.count();
+        return list.size();
     }
 
     public void insert(T value) {
-        group.insert(value);
+        list.add(value);
     }
 
     public Boolean has(T value) {
-        return group.has(value);
+        return list.contains(value);
 
     }
 
     public T fetch(int indexOfValue) {
-       // set.add(indexOfValue);
-        return null;
+        return list.get(indexOfValue);
     }
 
     public void delete(T value) {
-        //set.remove(value);
+        list.remove(value);
 
     }
 
     public void clear() {
+        list.clear();
     }
 
+    @Override
+    public String toString() {
+        return list.toString();
+    }
+
+    @Override
     public Iterator<T> iterator() {
         return null;
     }
 
     @Override
-    public String toString() {
-        return "Group{" +
-                "group=" + group +
-                '}';
+    public void forEach(Consumer<? super T> action) {
+
+    }
+
+    @Override
+    public Spliterator<T> spliterator() {
+        return null;
     }
 }

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,35 +1,49 @@
 package rocks.zipcode.io.quiz4.generics;
 
+import java.util.Iterator;
+import java.util.Spliterator;
 import java.util.Stack;
+import java.util.function.Consumer;
 
 /**
  * @author leon on 11/12/2018.
  */
-public class MyStack<SomeType> {
+public class MyStack<SomeType> implements Iterable<SomeType> {
     public MyStack() {
-        throw new UnsupportedOperationException("Method not yet implemented");
+        //throw new UnsupportedOperationException("Method not yet implemented");
     }
 
-    private SomeType[] array;
+   Stack<SomeType> stack = new Stack<>();
 
-    Stack stack = new Stack();
-
-    public Boolean isEmpty() {
+    public boolean isEmpty() {
         return stack.isEmpty();
     }
 
     public void push(SomeType i) {
-        if (stack.isEmpty()) {
-            stack.push(i);
-        }
+       stack.push(i);
     }
 
     public SomeType peek() {
-        throw new UnsupportedOperationException("Method not yet implemented");
+        //throw new UnsupportedOperationException("Method not yet implemented");
+        return stack.peek();
     }
 
     public SomeType pop() {
-        //return stack.pop();
+      return 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,23 @@
 package rocks.zipcode.io.quiz4.generics;
 
+import java.util.Collections;
 /**
  * @author leon on 18/12/2018.
  */
-public class SortedGroup<T> extends Group<T> {
+public class SortedGroup<T> extends Group<T>{
+
+    public Integer indexOf(T firstValue) {
+        Collections.sort(list,null);
+        return list.indexOf(firstValue);
+    }
     @Override
     public void insert(T value) {
+        list.add(value);
+        Collections.sort(list,null);
     }
 
     @Override
     public void delete(T value) {
-    }
-
-    public Integer indexOf(T firstValue) {
-        return null;
+        list.remove(value);
     }
 }

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

@@ -22,10 +22,9 @@ public class PalindromeObject {
         int n = input.length();
         for (int i = 0; i < (n/2); ++i) {
             if (input.charAt(i) != input.charAt(n - i - 1)) {
-                return false;
+                return true;
             }
         }
-
         return true;
     }
 

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

@@ -5,19 +5,11 @@ package rocks.zipcode.io.quiz4.objectorientation;
  */
 public class StringAssembler {
     public StringAssembler(Character delimeter) {
+
     }
 
     public StringAssembler append(String str) {
-        StringBuilder sb = new StringBuilder();
-        sb.append("You");
-        sb.append(str);
-        sb.append(" to ");
-        sb.append(str);
-        sb.append(" \"");
-        sb.append(str );
-        sb.append('"');
-        String s = sb.toString();
-        return null;
+       return null;
     }
 
     public String assemble() {

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

@@ -5,7 +5,7 @@ package rocks.zipcode.io.quiz4.objectorientation;
  */
 public class Student {
     private  Integer id;
-    private Double totalStudyTime;
+    private Double totalStudyTime = 0.0;
 
     public Student() {
         this(null);