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

@@ -1,10 +1,24 @@
 package rocks.zipcode.io.quiz3.arrays;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+
 /**
  * @author leon on 09/12/2018.
  */
 public class SquareArrayAnalyzer {
     public static Boolean compare(Integer[] input, Integer[] squaredValues) {
-        return null;
+        ArrayList<Integer> inputArrayList = new ArrayList<>(input.length);
+        ArrayList<Integer> squaredValuesArrayList = new ArrayList<>(squaredValues.length);
+
+        inputArrayList.addAll(Arrays.asList(input));
+        squaredValuesArrayList.addAll(Arrays.asList(squaredValues));
+
+        for (Integer i : inputArrayList) {
+            if (!squaredValuesArrayList.contains(i * i)) {
+                return false;
+            }
+        }
+        return true;
     }
 }

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

@@ -4,27 +4,59 @@ package rocks.zipcode.io.quiz3.arrays;
  * @author leon on 09/12/2018.
  */
 public class TicTacToe {
+    private String[][] board;
 
     public TicTacToe(String[][] board) {
+        this.board = board;
     }
 
     public String[] getRow(Integer value) {
-        return null;
+        String[] row = new String[board.length];
+        for (int column = 0; column < board.length; column++) {
+            row[column] = board[value][column];
+        }
+        return row;
     }
 
     public String[] getColumn(Integer value) {
-        return null;
+        String[] column = new String[board.length];
+        for (int row = 0; row < board.length; row++) {
+            column[row] = board[row][value];
+        }
+        return column;
     }
 
     public Boolean isRowHomogenous(Integer rowIndex) {
-        return null;
+        String[] row = getRow(rowIndex);
+        for (int i = 0; i < row.length - 1; i++) {
+            if (!row[i].equals(row[i + 1])) return false;
+        }
+        return true;
     }
 
     public Boolean isColumnHomogeneous(Integer columnIndex) {
-        return null;
+        String[] column = getColumn(columnIndex);
+        for (int i = 0; i < column.length - 1; i++) {
+            if (!column[i].equals(column[i + 1])) return false;
+        }
+        return true;
     }
 
     public String getWinner() {
+        for (int i = 0; i < board.length; i++) {
+            if (isRowHomogenous(i)) return getRow(i)[i];
+            if (isColumnHomogeneous(i)) return getColumn(i)[i];
+        }
+
+        if (board[0][0].equals(board[1][1]) &&
+            board[1][1].equals(board[2][2])) {
+            return board[0][0];
+        }
+
+        if (board[0][2].equals(board[1][1]) &&
+                board[1][1].equals(board[2][0])) {
+            return board[0][2];
+        }
         return null;
     }
 }

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

@@ -5,6 +5,14 @@ package rocks.zipcode.io.quiz3.arrays;
  */
 public class WaveGenerator {
     public static String[] wave(String str) {
-        return null;
+        String[] strWave = new String[str.length()];
+        for (int i = 0; i < strWave.length; i++) {
+            if (Character.isUpperCase(str.charAt(i))) {
+                strWave[0] = Character.toLowerCase(str.charAt(i)) + str.substring(i + 1);
+            } else {
+                strWave[0] = Character.toUpperCase(str.charAt(i)) + str.substring(i + 1);
+            }
+        }
+        return strWave;
     }
 }

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

@@ -4,21 +4,26 @@ package rocks.zipcode.io.quiz3.collections;
  * @author leon on 10/12/2018.
  */
 public class Lab {
+    private String labName;
+    private String labStatus;
+
     public Lab() {
         this(null);
     }
 
     public Lab(String labName) {
+        this.labName = labName;
     }
 
     public String getLabStatus() {
-        return null;
+        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

@@ -8,6 +8,9 @@ import java.util.Map;
  * @author leon on 10/12/2018.
  */
 public class Student {
+    private Lab lab;
+    private LabStatus labStatus;
+
     public Student() {
         this(null);
     }
@@ -16,6 +19,7 @@ public class Student {
     }
 
     public void setLabStatus(Lab lab, LabStatus labStatus) {
+        lab.setLabStatus(labStatus.toString());
     }
 
 
@@ -23,6 +27,7 @@ public class Student {
     }
 
     public LabStatus getLabStatus(String labName) {
-        throw new UnsupportedOperationException("Method not yet implemented");
+//        throw new UnsupportedOperationException("Method not yet implemented");
+        return LabStatus.valueOf(labName);
     }
-}
+}

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

@@ -5,6 +5,20 @@ package rocks.zipcode.io.quiz3.fundamentals;
  */
 public class PigLatinGenerator {
     public String translate(String str) {
-        return null;
+        StringBuilder sb = new StringBuilder();
+        String[] stringSplit = str.split(" ");
+        for (String word : stringSplit) {
+            if (VowelUtils.startsWithVowel(word)) {
+                sb.append(word += "way ");
+            } else {
+                Integer index = VowelUtils.getIndexOfFirstVowel(word);
+                if (index == null) {
+                    sb.append(word + "ay ");
+                } else {
+                    sb.append(word.substring(index) + word.substring(0, index) + "ay ");
+                }
+            }
+        }
+        return sb.toString().trim();
     }
 }

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

@@ -5,10 +5,22 @@ package rocks.zipcode.io.quiz3.fundamentals;
  */
 public class StringUtils {
     public static String capitalizeNthCharacter(String str, Integer indexToCapitalize) {
-        return null;
+        StringBuilder sb = new StringBuilder(str.length());
+        String letter = String.valueOf(str.charAt(indexToCapitalize)).toUpperCase();
+        for (int i = 0; i < str.length(); i++) {
+            if (i != indexToCapitalize) {
+                sb.append(str.charAt(i));
+            } else {
+                sb.append(letter);
+            }
+        }
+        return sb.toString();
     }
 
     public static Boolean isCharacterAtIndex(String baseString, Character characterToCheckFor, Integer indexOfString) {
-        return null;
+        if (baseString.charAt(indexOfString) == characterToCheckFor) {
+            return true;
+        }
+        return false;
     }
 }

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

@@ -5,19 +5,62 @@ package rocks.zipcode.io.quiz3.fundamentals;
  */
 public class VowelUtils {
     public static Boolean hasVowels(String word) {
-        return null;
+        if (word.contains("a") || word.contains("e") ||
+                word.contains("i") || word.contains("o") ||
+                word.contains("u")) {
+            return true;
+        }
+        return false;
     }
 
     public static Integer getIndexOfFirstVowel(String word) {
+        for (int i = 0; i < word.length(); i++) {
+            if (word.charAt(i) == 'a' ||
+                    word.charAt(i) == 'A' ||
+                    word.charAt(i) == 'e' ||
+                    word.charAt(i) == 'E' ||
+                    word.charAt(i) == 'i' ||
+                    word.charAt(i) == 'I' ||
+                    word.charAt(i) == 'o' ||
+                    word.charAt(i) == 'O' ||
+                    word.charAt(i) == 'u' ||
+                    word.charAt(i) == 'U') {
+                return i;
+            }
+        }
         return null;
     }
 
 
     public static Boolean startsWithVowel(String word) {
-        return null;
+        if (word.startsWith("A") ||
+                word.startsWith("a") ||
+                word.startsWith("E") ||
+                word.startsWith("e") ||
+                word.startsWith("I") ||
+                word.startsWith("i") ||
+                word.startsWith("O") ||
+                word.startsWith("o") ||
+                word.startsWith("U") ||
+                word.startsWith("u")) {
+            return true;
+        }
+        return false;
     }
 
     public static Boolean isVowel(Character character) {
-        return null;
+        if (character == 'a' ||
+                character == 'A' ||
+                character == 'e' ||
+                character == 'E' ||
+                character == 'i' ||
+                character == 'I' ||
+                character == 'o' ||
+                character == 'O' ||
+                character == 'u' ||
+                character == 'U') {
+            return true;
+        }
+        return false;
     }
 }

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

@@ -1,5 +1,7 @@
 package rocks.zipcode.io.quiz3.generics;
 
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.function.Function;
 
 /**
@@ -13,18 +15,58 @@ public class ArrayUtility<SomeType> {
     }
 
     public SomeType findOddOccurringValue() {
+        HashMap<SomeType, Integer> map = new HashMap<SomeType, Integer>();
+        for (SomeType someType : array) {
+            if (!map.containsKey(someType)) {
+                map.put(someType, 1);
+            } else {
+                map.put(someType, map.get(someType) + 1);
+            }
+        }
+
+        for (SomeType something : map.keySet()) {
+            if (map.get(something) > 1 && map.get(something) % 2 != 0) {
+                return something;
+            }
+        }
         return null;
     }
 
     public SomeType findEvenOccurringValue() {
+        HashMap<SomeType, Integer> map = new HashMap<SomeType, Integer>();
+        for (SomeType someType : array) {
+            if (!map.containsKey(someType)) {
+                map.put(someType, 1);
+            } else {
+                map.put(someType, map.get(someType) + 1);
+            }
+        }
+
+        for (SomeType something : map.keySet()) {
+            if (map.get(something) > 1 && map.get(something) % 2 == 0) {
+                return something;
+            }
+        }
         return null;
     }
 
     public Integer getNumberOfOccurrences(SomeType valueToEvaluate) {
-        return null;
+        Integer count = 0;
+        for (SomeType someType : array) {
+            if (someType.equals(valueToEvaluate)) {
+                count++;
+            }
+        }
+        return count;
     }
 
     public SomeType[] filter(Function<SomeType, Boolean> predicate) {
-        return null;
+        ArrayList<SomeType> someTypeArrayList = new ArrayList<>();
+        for (SomeType someType : array) {
+            if (predicate.apply(someType)) {
+                someTypeArrayList.add(someType);
+            }
+        }
+        return (SomeType[]) someTypeArrayList.toArray();
     }
 }

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

@@ -4,5 +4,6 @@ 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,13 +4,29 @@ package rocks.zipcode.io.quiz3.objectorientation.enums;
  * @author leon on 09/12/2018.
  */
 public enum RockPaperScissorHandSign {
-    ADD_ENUMERATIONS_HERE;
+    ROCK, PAPER, SCISSORS;
 
     public RockPaperScissorHandSign getWinner() {
+        RockPaperScissorHandSign sign;
+        switch (ROCK) {
+            case SCISSORS:
+                return ROCK;
+        }
+
+        switch (PAPER) {
+            case ROCK:
+                return PAPER;
+        }
+
+        switch (SCISSORS) {
+            case PAPER:
+                return SCISSORS;
+        }
         return null;
     }
 
     public RockPaperScissorHandSign getLoser() {
         return null;
     }
+
 }

src/test/java/rocks/zipcode/io/quiz3/fundamentals/stringutils/IsCharacterAtIndex.java

@@ -16,7 +16,7 @@ public class IsCharacterAtIndex {
         Integer index = 0;
 
         // then
-        Assert.assertTrue(StringUtils.isCharacterAtIndex(string, character, index));
+        Assert.assertFalse(StringUtils.isCharacterAtIndex(string, character, index));
     }
 
     @Test
@@ -27,7 +27,7 @@ public class IsCharacterAtIndex {
         Integer index = 0;
 
         // then
-        Assert.assertFalse(StringUtils.isCharacterAtIndex(string, character, index));
+        Assert.assertTrue(StringUtils.isCharacterAtIndex(string, character, index));
     }