src/main/java/rocks/zipcode/io/quiz3/arrays/SquareArrayAnalyzer.java

@@ -1,10 +1,30 @@
 package rocks.zipcode.io.quiz3.arrays;
 
+import java.util.Arrays;
+
 /**
  * @author leon on 09/12/2018.
+ * Given two arrays `a` and `b` write a method `compare(a, b)`
+ * that returns true if the two arrays have the "same" elements, with the same multiplicities. "
+ * Same" means, here, that the elements
+ * in `b` are the elements in `a` squared, regardless of the order.
  */
 public class SquareArrayAnalyzer {
+
+
     public static Boolean compare(Integer[] input, Integer[] squaredValues) {
-        return null;
+        Arrays.sort(input);
+        Arrays.sort(squaredValues );
+        boolean flag=false;
+        for(int i=0;i<input.length;i++ ){
+            if(squaredValues[i]%input[i]==0 ){
+                flag=true;
+            }
+            else
+                flag=false;
+        }
+
+
+        return flag;
     }
 }

src/main/java/rocks/zipcode/io/quiz3/arrays/TicTacToe.java

@@ -1,30 +1,92 @@
 package rocks.zipcode.io.quiz3.arrays;
 
+import java.util.Arrays;
+
 /**
  * @author leon on 09/12/2018.
  */
 public class TicTacToe {
+    String[][] board;
+
 
     public TicTacToe(String[][] board) {
+
+        this.board = board;
     }
 
     public String[] getRow(Integer value) {
+
         return null;
     }
 
     public String[] getColumn(Integer value) {
+
         return null;
     }
 
     public Boolean isRowHomogenous(Integer rowIndex) {
-        return null;
+        for (int i = 0; i < rowIndex; i++) {
+            return true;
+
+        }
+        return false;
     }
 
     public Boolean isColumnHomogeneous(Integer columnIndex) {
-        return null;
+      for(int i=0;i<columnIndex;i++ ) {
+          return true;
+      }
+
+          return false;
     }
 
     public String getWinner() {
-        return null;
+
+
+        String[] board = new String[9];
+        String turn = "X";
+        for (int a = 0; a < 8; a++) {
+            String line = null;
+            switch (a) {
+                case 0:
+                    line = board[0] + board[1] + board[2];
+                    break;
+                case 1:
+                    line = board[3] + board[4] + board[5];
+                    break;
+                case 2:
+                    line = board[6] + board[7] + board[8];
+                    break;
+                case 3:
+                    line = board[0] + board[3] + board[6];
+                    break;
+                case 4:
+                    line = board[1] + board[4] + board[7];
+                    break;
+                case 5:
+                    line = board[2] + board[5] + board[8];
+                    break;
+                case 6:
+                    line = board[0] + board[4] + board[8];
+                    break;
+                case 7:
+                    line = board[2] + board[4] + board[6];
+                    break;
+            }
+            if (line.equals("XXX")) {
+                return "X";
+            } else if (line.equals("OOO")) {
+                return "O";
+            }
+        }
+        for (int a = 0; a < 9; a++) {
+            if (Arrays.asList(board).contains(String.valueOf(a+1))) {
+                break;
+            }
+            else if (a == 8)
+                return turn;
+        }
+        return turn;
+
     }
 }

src/main/java/rocks/zipcode/io/quiz3/arrays/WaveGenerator.java

@@ -1,10 +1,46 @@
 package rocks.zipcode.io.quiz3.arrays;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
 /**
  * @author leon on 09/12/2018.
  */
 public class WaveGenerator {
     public static String[] wave(String str) {
-        return null;
+//
+//        // iterate through string
+//        // for every character in string
+//        // capitalize that character and return that string
+
+
+          int n = str.length();
+          String s = str.toLowerCase();
+          ArrayList <String> st = new ArrayList<>();
+          StringBuffer temp = new StringBuffer();
+
+
+          String alpha;
+          for (int i = 0; i < n; i++) {
+
+              alpha = s.substring(i, i + 1);
+              if (isAlphaString(alpha)) {
+                  temp = new StringBuffer();
+                  temp.append(s.substring(0, i));
+                  temp.append(s.substring(i, i + 1).toUpperCase());
+                  temp.append(s.substring(i + 1));
+
+                  st.add(temp.toString());
+              }
+          }
+        return st.toArray(new String[st.size()]);
+    }
+
+
+    public static Boolean isAlphaString(String string) {
+
+        return string .matches("[a-zA-Z]+");
     }
 }

src/main/java/rocks/zipcode/io/quiz3/collections/Lab.java

@@ -4,21 +4,30 @@ package rocks.zipcode.io.quiz3.collections;
  * @author leon on 10/12/2018.
  */
 public class Lab {
+      String labName;
+      String labStatus;
+
     public Lab() {
-        this(null);
+        //this(null);
     }
 
     public Lab(String labName) {
+
+        this.labName =labName ;
     }
 
-    public String getLabStatus() {
-        return null;
+   public String getLabStatus() {
+
+        return labStatus ;
     }
 
     public void setLabStatus(String labStatus) {
+
+        this.labStatus =labStatus ;
     }
 
     public String getName() {
-        return null;
+
+        return labName ;
     }
 }

src/main/java/rocks/zipcode/io/quiz3/collections/Student.java

@@ -1,28 +1,44 @@
 package rocks.zipcode.io.quiz3.collections;
 
+import javafx.scene.Parent;
 import rocks.zipcode.io.quiz3.objectorientation.enums.LabStatus;
 
+import javax.xml.soap.SOAPPart;
+import java.util.HashMap;
 import java.util.Map;
 
 /**
  * @author leon on 10/12/2018.
  */
 public class Student {
+
+    Map<Lab, LabStatus >hm;
+
     public Student() {
-        this(null);
+
+        this.hm =new HashMap<>();
+        //this(null);
     }
 
     public Student(Map<Lab, LabStatus> map) {
-    }
 
-    public void setLabStatus(Lab lab, LabStatus labStatus) {
+        this.hm=map;
     }
 
+    public void setLabStatus(Lab lab, LabStatus labStatus) {
+      hm.put(lab,labStatus );
 
+    }
     public void forkLab(Lab lab) {
+        LabStatus temp = hm.put(lab, LabStatus.PENDING);
+        System .out.println(temp);
     }
 
     public LabStatus getLabStatus(String labName) {
-        throw new UnsupportedOperationException("Method not yet implemented");
+        try {
+            return hm.get(labName);
+        } catch (Exception e) {
+            throw new UnsupportedOperationException("Method not yet implemented");
+        }
     }
 }

src/main/java/rocks/zipcode/io/quiz3/fundamentals/PigLatinGenerator.java

@@ -1,10 +1,66 @@
 package rocks.zipcode.io.quiz3.fundamentals;
 
+import java.util.regex.Pattern;
+
 /**
  * @author leon on 09/12/2018.
+ * Pig Latin is an English language game where the goal is to hide the meaning of a word f
+ * rom people not aware of the rules.
+ * * The rules themselves are rather easy:
+ * * 1) The word starts with a vowel(a,e,i,o,u) -> return the original string plus "way".
+ * * 2) The word starts with a consonant -> move consonants from the beginning of the word
+ * to the end of the word until the first vowel, then return it plus "ay".
+ * * 3) The result must be lowercase, regardless of the case of the input. If the input
+ * string has any non-alpha characters, the function must return None, null, Nothing (depending on the language).
+ * * 4) The function must also handle simple random strings and not just English words.
+ * * 5) The input string has no vowels -> return the original string plus "ay".
+ * * For example, the word "spaghetti" becomes "aghettispay" because the first two letters ("sp")
+ * are consonants, so they are moved to the end of the string and "ay" is appended.
+ *
  */
 public class PigLatinGenerator {
+
     public String translate(String str) {
-        return null;
+        String s = "";
+        char ch[] = str.toCharArray();
+
+
+        String[] words = str.split("\\s+");
+        String answer = "";
+
+        if (str.startsWith("a") || str.startsWith("e") || str.startsWith("i") || str.startsWith("o") || str.startsWith("u")) {
+            System.out.print(str + "way");
+            return str.concat("way");
+        } else {
+            answer = str.substring(2, str.length());
+            String answer2 = str.substring(1, str.length());
+            String answer3 = str.substring(3, str.length());
+            String answer4 = str.substring(4, str.length());
+            String d = str.substring(0, 4);
+            if (!(d.contains("a") || d.contains("e") || d.contains("i") || d.contains("o") || d.contains("u"))) {
+               // System.out.print(answer4 + d + "ay");
+                return answer4.concat(d).concat("ay");
+            } else {
+                String c = str.substring(0, 3);
+                if (!(c.contains("a") || c.contains("e") || c.contains("i") || c.contains("o") || c.contains("u"))) {
+                   // System.out.print(answer3 + c + "ay");
+                    return answer3.concat(c).concat("ay");
+                } else {
+                    String b = str.substring(0, 2);
+                    if (!(b.contains("a") || b.contains("e") || b.contains("i") || b.contains("o") || b.contains("u"))) {
+                      //  System.out.print(answer + b + "ay");
+                        return answer.concat(b).concat("ay");
+                    } else {
+                        String a = str.substring(0, 1);
+                        if (!(a.contains("a") || a.contains("e") || a.contains("i") || a.contains("o") || a.contains("u"))) {
+                           // System.out.print(answer2 + a + "ay");
+                            return answer2.concat(a).concat("ay");
+                        }
+                    }
+                }
+            }
+        }
+     return null;
     }
 }
+

src/main/java/rocks/zipcode/io/quiz3/fundamentals/StringUtils.java

@@ -5,10 +5,24 @@ package rocks.zipcode.io.quiz3.fundamentals;
  */
 public class StringUtils {
     public static String capitalizeNthCharacter(String str, Integer indexToCapitalize) {
-        return null;
+        char[] arr2 = str.toCharArray();
+
+        arr2[indexToCapitalize] = Character.toUpperCase(arr2[indexToCapitalize]);
+        String str2 = new String(arr2);
+ return str2;
+
     }
 
     public static Boolean isCharacterAtIndex(String baseString, Character characterToCheckFor, Integer indexOfString) {
-        return null;
+
+
+       String s=Character .toString(baseString .charAt(indexOfString ));
+       if (s.equals(characterToCheckFor ) ){
+           return true;
+       }
+       else
+           return false;
+
+
     }
 }

src/main/java/rocks/zipcode/io/quiz3/fundamentals/VowelUtils.java

@@ -1,23 +1,64 @@
 package rocks.zipcode.io.quiz3.fundamentals;
 
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
 /**
  * @author leon on 09/12/2018.
  */
 public class VowelUtils {
     public static Boolean hasVowels(String word) {
-        return null;
+
+//        String x = word.toLowerCase();
+//        if(x.indexOf('e' || 'a' || 'i' || 'o' || 'u')) {
+//            return true;
+//        } else {
+//            return false;
+//        }
+
+        char[] words = word.toCharArray();
+        for(int i = 0; i<words.length; i++){
+            char z = words[i];
+            if (z=='a'||z=='e'||z=='i'||z=='o'||z=='u') return true;
+        }
+        return false;
     }
 
     public static Integer getIndexOfFirstVowel(String word) {
+        for (int i = 0; i < word.length(); i++) {
+            char c = word.charAt(i);
+            if ("AEIOUaeiou".indexOf(c) != -1)
+                return word.indexOf(c);
+        }
         return null;
     }
 
 
+
+
+
     public static Boolean startsWithVowel(String word) {
-        return null;
+        char ch;
+
+        ch = word.charAt(0);
+
+        if(ch=='a' || ch=='A' || ch=='e' || ch=='E' ||
+                ch=='i' || ch=='I' || ch=='o' || ch=='O' ||
+                ch=='u' || ch=='U')
+        {
+           return true;
+        }
+        else
+        {
+           return false;
+        }
+
+
     }
 
     public static Boolean isVowel(Character character) {
-        return null;
+
+
+       return "AEIOUaeiou".indexOf(character ) != -1;
     }
 }

src/main/java/rocks/zipcode/io/quiz3/generics/ArrayUtility.java

@@ -1,5 +1,6 @@
 package rocks.zipcode.io.quiz3.generics;
 
+import java.util.*;
 import java.util.function.Function;
 
 /**
@@ -9,22 +10,78 @@ public class ArrayUtility<SomeType> {
     private final SomeType[] array;
 
     public ArrayUtility(SomeType[] array) {
+
         this.array = array;
     }
 
     public SomeType findOddOccurringValue() {
-        return null;
+        if(array.length==1){
+            return array[0];
+        }
+        Arrays.sort(array);
+        for(int i=0;i<array.length-1;){
+            if(array[i]==array[i+1]){
+                i+=2;
+            }else{
+                return array[i+1];
+            }
+        }
+        return array[array.length-1];
+
     }
 
+
+
+
+
+
     public SomeType findEvenOccurringValue() {
+
+//        if(array.length==1){
+//            return array[0];
+//        }
+//        Arrays.sort(array);
+//        for(int i=0;i<array.length-1;){
+//            if(array[i]!==array[i+1]){
+//                i+=2;
+//            }else{
+//                return array[i];
+//            }
+//        }
+//        return array[array.length-1];
+
+        for (int i = 0; i < array.length; i++) {
+            int count = 0;
+            for (int j = 0; j < array.length; j++) {
+                if (array[i] == array[j]) {
+                    count++;
+                }
+
+            }
+            if (count % 2 == 0) {
+                return array[i];
+            }
+
+        }
         return null;
     }
 
+
     public Integer getNumberOfOccurrences(SomeType valueToEvaluate) {
-        return null;
+
+        Arrays.sort(array);
+        int  nbOccurences = 0;
+
+        for (int i = 0, length = array.length ; i < length; i++) {
+            if (array[i] == valueToEvaluate ) {
+                nbOccurences++;
+            }
+        }
+       return nbOccurences;
     }
 
     public SomeType[] filter(Function<SomeType, Boolean> predicate) {
+
         return null;
     }
 }

src/main/java/rocks/zipcode/io/quiz3/objectorientation/enums/LabStatus.java

@@ -4,5 +4,7 @@ package rocks.zipcode.io.quiz3.objectorientation.enums;
  * @author leon on 10/12/2018.
  */
 public enum LabStatus {
-    ADD_ENUMERATIONS_HERE;
+    // ADD_ENUMERATIONS_HERE;
+    PENDING,COMPLETED,INCOMPLETE,
 }
+

src/main/java/rocks/zipcode/io/quiz3/objectorientation/enums/RockPaperScissorHandSign.java

@@ -4,12 +4,15 @@ package rocks.zipcode.io.quiz3.objectorientation.enums;
  * @author leon on 09/12/2018.
  */
 public enum RockPaperScissorHandSign {
-    ADD_ENUMERATIONS_HERE;
+    //ADD_ENUMERATIONS_HERE;
+    ROCK,PAPER,SESSIORS;
+
 
     public RockPaperScissorHandSign getWinner() {
         return null;
     }
 
+
     public RockPaperScissorHandSign getLoser() {
         return null;
     }

src/test/java/rocks/zipcode/io/quiz3/arrays/wavegenerator/WaveTest.java

@@ -144,7 +144,7 @@ public class WaveTest {
 
         // when
         String[] actual = WaveGenerator.wave(input);
-
+        System.out.println(actual);
         // then
         TestUtils.assertArrayEquals(expected, actual);
     }