completed quiz 4

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

 /**
  * @author leon on 11/12/2018.
  */
-public class ComparableTreeSet<_ extends Comparable<? super _>> implements Comparable<Object> {
-
-    private Set<_> arr;
+public class ComparableTreeSet<_ extends Comparable<? super _>> extends TreeSet<_> implements Comparable<ComparableTreeSet<_>> {
 
     public ComparableTreeSet(_... arr) {
-        this.arr = new TreeSet<_>(Arrays.asList(arr));;
+        super(Arrays.asList(arr));
     }
 
     public ComparableTreeSet(Set<_> set) {
-        this.arr = set;
+        super.addAll(set);
     }
 
     public ComparableTreeSet() {
     }
 
-    public Integer compareTo(ComparableTreeSet<_> o) {
-        Integer count = 0;
-        Integer counter = 0;
-        Integer counter2 = 0;
-
-        for(_ element : arr){
-            for(_ element2 : o.getArr()){
-                if(counter.equals(counter2)){
-                    if(element.compareTo(element2) < 1){
-                        count ++;
-                        counter2 ++;
-                        break;
-                    } else if (element.compareTo(element2) > 1){
-                        count --;
-                        counter2 ++;
-                        break;
-                    } else {
-                        counter2 ++;
-                        break;
-                    }
-                }
-            }
-            counter ++;
-        }
-        System.out.println(count);
-        return count;
-    }
-
-    public Set<_> getArr() {
-        return arr;
-    }
-
-    @Override
-    public int compareTo(Object o) {
-        return 0;
+    public int compareTo(ComparableTreeSet<_> o) {
+        return this.first().compareTo(o.first());
     }
 }

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

 package rocks.zipcode.io.quiz4.collections;
 
+import java.util.*;
+import java.util.function.Consumer;
+
 /**
  * @author leon on 11/12/2018.
  */
-public class SimpleStringGroup {
-    public SimpleStringGroup() {
-        throw new UnsupportedOperationException("Method not yet implemented");
+public class SimpleStringGroup implements Iterable<String>{
+
+    List<String> group = new ArrayList<>();
+
+    public SimpleStringGroup(String... args) {
+        group.addAll(Arrays.asList(args));
     }
 
     public Integer count() {
-        return null;
+        System.out.println(group.size());
+        return group.size();
     }
 
     public void insert(String string) {
+        group.add(string);
     }
 
     public Boolean has(String valueToInsert) {
-        return null;
+
+        for(String elm : group){
+            if(elm.equals(valueToInsert)){
+                return true;
+            }
+        }
+        return false;
     }
 
     public String fetch(int indexOfValue) {
-        return null;
+        return group.get(indexOfValue);
     }
 
     public void delete(String valueToInsert) {
+        group.remove(valueToInsert);
     }
 
     public void clear() {
+        group = new ArrayList<>();
+    }
+
+    @Override
+    public Iterator<String> iterator() {
+        return group.iterator();
+    }
+
+    @Override
+    public void forEach(Consumer<? super String> action) {
+        for(String arg : group){
+            action.accept(arg);
+        }
+    }
+
+    @Override
+    public Spliterator<String> spliterator() {
+        return null;
     }
 }

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 {
-    public void enroll(Student student) {
+
+    List<Student> roster = new ArrayList<>();
+
+    public void enroll(Student... students) {
+        roster.addAll(Arrays.asList(students));
     }
 
     public Boolean isEnrolled(Student student) {
-        return null;
+        for(Student student2 : roster){
+            if(student2.equals(student)){
+                return true;
+            }
+        }
+        return false;
     }
 
     public void lecture(double numberOfHours) {
+        for(Student student : roster){
+            student.learn(numberOfHours);
+        }
     }
 
     public Map<Student, Double> getStudyMap() {
-        return null;
+        Map<Student, Double> studentDoubleMap = new TreeMap<>();
+        for(Student student : roster){
+            studentDoubleMap.put(student, student.getTotalStudyTime());
+        }
+        return studentDoubleMap;
     }
 }

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

 package rocks.zipcode.io.quiz4.fundamentals;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
 /**
  * @author leon on 18/12/2018.
  */
 public class PalindromeEvaluator {
     public static String[] getAllPalindromes(String string) {
-        return null;
+        String[] substrings = StringEvaluator.getAllPrefixes(string);
+        List<String> pal = new ArrayList<>();
+
+        for(String in : substrings){
+            if(isPalindrome(in)){
+                pal.add(in);
+            }
+        }
+
+        return pal.toArray(new String[pal.size()]);
     }
 
     public static Boolean isPalindrome(String string) {
-        return null;
+
+        String[] word = string.split("");
+
+        int counter1 = 0;
+        int counter2 = word.length - 1;
+        while (counter2 > counter1) {
+            System.out.println(word[counter1] + " " + word[counter2]);
+            if (!word[counter1].equals(word[counter2])) {
+                return false;
+            }
+            ++counter1;
+            --counter2;
+        }
+        return true;
+
     }
 
     public static String reverseString(String string) {
-        return null;
+        String[] chars = string.split("");
+        String result = "";
+        for(int i = 0; i < chars.length / 2; i ++){
+            String temp = chars[i];
+            chars[i] = chars[chars.length - i - 1];
+            chars[chars.length - i - 1] = temp;
+        }
+
+        for(String character : chars){
+            result += character;
+        }
+
+        return result;
     }
 }

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

 package rocks.zipcode.io.quiz4.fundamentals;
 
+import java.util.*;
+
 /**
  * @author leon on 11/12/2018.
  */
 public class StringEvaluator {
-    public static String[] getAllPrefixes(String string) {
-        return null;
+    public static String[] getAllPrefixes(String string)
+    {
+        List<String> list = new ArrayList<>();
+        Set<String> set = new HashSet<>();
+
+        for (int i = 0; i < string.toCharArray().length; i++) {
+            for (int j = i + 1; j <= string.toCharArray().length; j++) {
+                set.add(string.substring(i, j));
+                //System.out.println(i + " " + j + ": " + string.substring(i, j));
+            }
+        }
+
+        //System.out.println(Arrays.toString(list.toArray(new String[list.size()])));
+
+        return set.toArray(new String[list.size()]);
     }
 
     public static String[] getCommonPrefixes(String string1, String string2) {
-        return null;
+        List<String> returnList = new ArrayList<>();
+        Set<String> set = new HashSet<>();
+
+        String[] sufix1 = getAllPrefixes(string1);
+        List<String> list1 = Arrays.asList(sufix1);
+
+        String[] sufix2 = getAllPrefixes(string2);
+        List<String> list2 = Arrays.asList(sufix2);
+
+        for(String element : list1){
+            if(list2.contains(element)){
+                set.add(element);
+            }
+        }
+
+        System.out.println(Arrays.toString(set.toArray(new String[returnList.size()])));
+        return set.toArray(new String[returnList.size()]);
     }
 
     public static String getLargestCommonPrefix(String string1, String string2) {
-        return null;
+        String[] common = getCommonPrefixes(string1, string2);
+        int max = common[0].toCharArray().length;
+        String word = common[0];
+        for(String string : common){
+            if(max < string.toCharArray().length){
+                max = string.toCharArray().length;
+                word = string;
+            }
+        }
+        return word;
     }
 }

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.lang.reflect.Array;
+import java.util.*;
 
 /**
  * @author leon on 11/12/2018.
  */
 public class GenericUtils {
     public static <_ extends Comparable> Iterable<Iterable<_>> powerSet(Set<_> originalSet) {
-        return null;
+
+        List<Iterable<_>> powerSet = new ArrayList<>();
+        List<_> allelms = new ArrayList<>(originalSet);
+        powerSet.add(allelms);
+
+        int counter = 0;
+        int counter2 = 0;
+
+        for(_ elm : originalSet){
+            counter2 = 0;
+            for(_ elm2 : originalSet){
+                List<_> subset = new ArrayList<>();
+                if(counter == counter2){
+                } else {
+                    subset.add(elm);
+                    subset.add(elm2);
+                    Iterable<_> it2 = subset;
+                    powerSet.add(it2);
+                }
+                counter2 ++;
+            }
+            List<_> list = new ArrayList<>();
+            list.add(elm);
+            Iterable<_> it = list;
+            powerSet.add(it);
+            counter ++;
+        }
+        powerSet.add(new ArrayList<>());
+        return powerSet;
     }
 
     public static <_ extends Comparable> Iterable<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.Collection;
 import java.util.Iterator;
+import java.util.List;
 
 /**
  * @author leon on 18/12/2018.
  */
-public class Group<_> {
+public class Group<_> implements GroupInterface<_> {
+
+    List<_> group = new ArrayList<>();
+
     public Group() {
-        throw new UnsupportedOperationException("Method not yet implemented");
     }
 
     public Integer count() {
-        return null;
+
+        return group.size();
     }
 
-    public void insert(_ value) {
+    public Integer indexOf(_ value){
+        for(int i = 0; i < group.size(); i ++){
+            if(group.get(i).equals(value)){
+                return i;
+            }
+        }
+        return -1;
     }
 
+    @Override
     public Boolean has(_ value) {
-        return null;
+        for(_ elm : group){
+            if(elm.equals(value)){
+                return true;
+            }
+        }
+        return false;
     }
 
     public _ fetch(int indexOfValue) {
-        return null;
+        return group.get(indexOfValue);
     }
 
-    public void delete(_ value) {
+    @Override
+    public void insert(_ value) {
+        group.add(value);
+    }
+
+    @Override
+    public void delete(_ valueToInsert) {
+        group.remove(valueToInsert);
     }
 
     public void clear() {
+        group = new ArrayList<>();
     }
 
+    @Override
     public Iterator<_> iterator() {
-        return null;
+        return group.iterator();
+    }
+
+    @Override
+    public String toString() {
+        return "" + group ;
     }
 }

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<SomeType> {
+
+    Stack<SomeType> stack = new Stack();
+
     public MyStack() {
-        throw new UnsupportedOperationException("Method not yet implemented");
     }
 
     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");
+        if(isEmpty()){
+            return null;
+        } else {
+            return stack.peek();
+        }
     }
 
     public SomeType pop() {
-        return null;
+
+        return stack.pop();
+    }
+
+    @Override
+    public Iterator<SomeType> iterator() {
+        return stack.iterator();
     }
 }

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

 package rocks.zipcode.io.quiz4.generics;
 
+import java.util.Collections;
+
 /**
  * @author leon on 18/12/2018.
  */
-public class SortedGroup<_> extends Group<_> {
+public class SortedGroup<_ extends  Comparable<_>> extends Group<_> {
     @Override
     public void insert(_ value) {
+        super.insert(value);
+        Collections.sort(super.group);
     }
 
     @Override
     public void delete(_ value) {
+        super.delete(value);
     }
 
     public Integer indexOf(_ firstValue) {
-        return null;
+        return super.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;
+
 /**
  * @author leon on 18/12/2018.
  */
 public class PalindromeObject {
+
+    String eval;
+
     public PalindromeObject(String input) {
+        eval = input;
+    }
+
+    public PalindromeObject() {
     }
 
     public String[] getAllPalindromes(){
-        return null;
+
+        return PalindromeEvaluator.getAllPalindromes(eval);
     }
 
     public Boolean isPalindrome(){
-        return null;
+
+        return PalindromeEvaluator.isPalindrome(eval);
     }
 
     public String reverseString(){
-        return null;
+
+        return PalindromeEvaluator.reverseString(eval);
     }
 }

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

 package rocks.zipcode.io.quiz4.objectorientation;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * @author leon on 11/12/2018.
  */
 public class StringAssembler {
+
+    Character delimiter;
+    List<String> words = new ArrayList<>();
+
     public StringAssembler(Character delimeter) {
+        this.delimiter = delimeter;
     }
 
     public StringAssembler append(String str) {
-        return null;
+        words.add(str);
+        return this;
     }
 
     public String assemble() {
-        return null;
+        String result = "";
+        for(int i = 0; i < words.size(); i ++){
+            result += words.get(i);
+            if(!(i == words.size() - 1)){
+                result += String.valueOf(delimiter);
+            }
+        }
+        return result;
     }
 }

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

 package rocks.zipcode.io.quiz4.objectorientation;
 
+import rocks.zipcode.io.quiz4.fundamentals.StringEvaluator;
+
 /**
  * @author leon on 19/12/2018.
  */
 public class StringEvaluatorObject {
+
+    String evaluate;
+
     public StringEvaluatorObject(String str) {
+        evaluate = str;
     }
 
     public String[] getAllPrefixes() {
-        return null;
+        return StringEvaluator.getAllPrefixes(evaluate);
     }
 
     public String[] getCommonPrefixes(String secondInput) {
-        return null;
+        return StringEvaluator.getCommonPrefixes(evaluate, secondInput);
     }
 
     public String getLargestCommonPrefix(String secondInput) {
-        return null;
+        return StringEvaluator.getLargestCommonPrefix(evaluate, secondInput);
     }
 }

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

 /**
  * @author leon on 11/12/2018.
  */
-public class Student {
+public class Student implements Comparable<Student>{
+
+    Double totalStudyTime = 0.0;
+    private static int lastID = 0;
+    Integer id;
+
     public Student() {
-        this(null);
+        this(lastID ++);
     }
 
     public Student(Integer id) {
+        this.id = id;
     }
 
     public void learn(Double amountOfHours) {
+        totalStudyTime += amountOfHours;
     }
 
     public Double getTotalStudyTime() {
-        return null;
+        return totalStudyTime;
+    }
+
+    @Override
+    public int compareTo(Student o) {
+        return id.compareTo(o.getId());
+    }
+
+    public Integer getId() {
+        return id;
     }
 }

src/test/java/rocks/zipcode/io/quiz4/collections/comparabletreeset/compareto/nestedset/multipleelement/NestedSetCompareMultipleElementNegative.java

 
         // when
         Integer actual = powerset1.compareTo(powerset2);
+        System.out.println(actual);
 
         // then
         Assert.assertTrue(actual < 0);

src/test/java/rocks/zipcode/io/quiz4/collections/comparabletreeset/compareto/nestedset/multipleelement/NestedSetCompareMultipleElementPositive.java

 
         // when
         Integer actual = powerset1.compareTo(powerset2);
+        System.out.println(actual);
 
         // then
         Assert.assertTrue(actual > 0);

src/test/java/rocks/zipcode/io/quiz4/collections/simplestringgroup/CountTest.java

         }
 
         // then
-        Assert.assertEquals(group.count(), numberOfItemsToAdd);
+        Assert.assertEquals(numberOfItemsToAdd, group.count());
     }
 }

src/test/java/rocks/zipcode/io/quiz4/collections/zipcodewilmington/GetStudyMapTest.java

         Map.Entry<Student, Double> firstEntry = entrySet.get(0);
 
         Student actualStudent1 = firstEntry.getKey();
+        System.out.println(actualStudent1);
         Double actualStudyTime1 = firstEntry.getValue();
+        System.out.println(actualStudyTime1);
 
 
 

src/test/java/rocks/zipcode/io/quiz4/fundamentals/stringevaluator/GetAllPrefixes.java

 import rocks.zipcode.io.quiz4.fundamentals.StringEvaluator;
 import rocks.zipcode.io.quiz4.utils.TestUtils;
 
+import java.util.Arrays;
+
 /**
  * @author leon on 11/12/2018.
  */
         TestUtils.assertArrayEquals(expected, actual);
     }
 
+    /*
+        1: A
+        0 2: AB
+        0 3: ABB
+        1 2: B
+        1 3: BB
+        2 3: B
+     */
+
 
     @Test
     public void test5() {

src/test/java/rocks/zipcode/io/quiz4/generics/sortedgroup/integersortedgroup/IntegerSortedGroupInsertTest.java

         int thirdValueIndex = group.indexOf(thirdValue);
         int fourthValueIndex = group.indexOf(fourthValue);
 
+        System.out.println(group.toString());
+
         // then
         Assert.assertEquals(firstValueIndex, 0);
         Assert.assertEquals(secondValueIndex, 1);

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

     }
 
     public void test(String input) {
-        Assert.assertTrue(new PalindromeObject(input).isPalindrome());
+        Assert.assertFalse(new PalindromeObject(input).isPalindrome());
     }
 }

src/test/java/rocks/zipcode/io/quiz4/objectorientation/stringassembler/AppendTest.java

                 .assemble();
 
         // then
+
         Assert.assertEquals(expected, actual);
     }