over 75% complete

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

 package rocks.zipcode.io.quiz3.arrays;
 
+import java.util.Arrays;
+
 /**
  * @author leon on 09/12/2018.
  */
 public class SquareArrayAnalyzer {
     public static Boolean compare(Integer[] input, Integer[] squaredValues) {
+        Integer[] sqrArr = new Integer[input.length];
+        for (int i = 0; i < input.length; i++) {
+             sqrArr[i] = input[i] * input[i];
+        }
+        int c = 0;
+        for (Integer integer : sqrArr){
+            if (integer.equals(squaredValues[c])){
+                return true;
+            }
+        }
 
-        return null;
+        return false;
     }
 }

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

  */
 public class TicTacToe {
 
+    private String[][] board;
+
+    public TicTacToe() {
+
+    }
+
     public TicTacToe(String[][] board) {
+        this.board = board;
     }
 
     public String[] getRow(Integer value) {
-        return null;
+        return board[value];
     }
 
     public String[] getColumn(Integer value) {
-        return null;
+        String[] column = new String[board[0].length];
+        for(int i=0; i<column.length; i++){
+            column[i] = board[i][value];
+        }
+        return column;
     }
 
     public Boolean isRowHomogenous(Integer rowIndex) {
-        return null;
+        String[] arr = getRow(rowIndex);
+        int c = 0;
+        for (int i = 0; i < arr.length; i++) {
+            for (String tic : arr) {
+                if (tic.equals(arr[i])) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
     }
 
     public Boolean isColumnHomogeneous(Integer columnIndex) {
-        return null;
+
+        String[] arr = getColumn(columnIndex);
+        int c = 0;
+        for (int i = 0; i < arr.length; i++) {
+            for (String tic : arr) {
+                if (tic.equals(arr[i])) {
+                    return true;
+                }
+            }
+        }
+        return false;
     }
 
+
     public String getWinner() {
         return null;
     }

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

 package rocks.zipcode.io.quiz3.arrays;
 
+import rocks.zipcode.io.quiz3.fundamentals.StringUtils;
+
+import java.util.Arrays;
+
 /**
  * @author leon on 09/12/2018.
  */
 public class WaveGenerator {
+
     public static String[] wave(String str) {
-        return null;
+        int count =0;
+        for (int i = 0; i < str.length(); i++) {
+            if(Character.isLetter(str.charAt(i))){
+                count++;
+            }
+        }
+        String[] wave = new String[count];
+        String waveStr = "";
+        int c = 0;
+        for (int i = 0; i < str.length(); i++) {
+            if(Character.isLetter(str.charAt(i))){
+                waveStr = StringUtils.capitalizeNthCharacter(str.toLowerCase(), i);
+                wave[c] = waveStr;
+                c++;
+            }
+
+        }
+        return wave;
     }
 }

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

 package rocks.zipcode.io.quiz3.collections;
 
+import rocks.zipcode.io.quiz3.objectorientation.enums.LabStatus;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
 /**
  * @author leon on 10/12/2018.
  */
 public class Lab {
+
+    private String labName;
+    private String labStatus;
+
+    List<Lab> labs;
+
     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

 
 import rocks.zipcode.io.quiz3.objectorientation.enums.LabStatus;
 
+import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 /**
  * @author leon on 10/12/2018.
  */
 public class Student {
+
+    private Lab lab;
+    private LabStatus labStatus;
+
+    Map<Lab, LabStatus> Labs;
+
     public Student() {
-        this(null);
+        this(new HashMap<>());
     }
 
     public Student(Map<Lab, LabStatus> map) {
+        this.Labs = map;
     }
 
     public void setLabStatus(Lab lab, LabStatus labStatus) {
+        Labs.put(lab, labStatus);
     }
 
 
     public void forkLab(Lab lab) {
+
     }
 
     public LabStatus getLabStatus(String labName) {
         throw new UnsupportedOperationException("Method not yet implemented");
     }
+
 }

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

 
     private static final char[] vowels = {'a', 'e', 'i', 'o', 'u'};
 
+    private static int firstVowel(String word) {
+        word = word.toLowerCase();
+        for (int i=0; i<word.length(); i++)
+            if (word.charAt(i)=='a' || word.charAt(i)=='e' ||
+                    word.charAt(i)=='i' || word.charAt(i)=='o' ||
+                    word.charAt(i)=='u')
+                return i;
+        return 0;
+    }
 
     public String translate(String str) {
-//
-//        int start = 0; // start index of word
-//        int firstVowel = 0;
-//        int end = str.length(); // end index of word
-//        for(int i = 0; i < end; i++) { // loop over length of word
-//            char c = Character.toLowerCase(str.charAt(i)); // char of word at i, lower cased
-//            if(Arrays.asList(vowels).contains(c)) { // convert vowels to a list so we can use List.contains() convenience method.
-//                firstVowel = i;
-//                break; // stop looping
-//            }
-//        }
-//        if(start != firstVowel) { // if start is not equal to firstVowel, we caught a vowel.
-//            String startString = str.substring(firstVowel, end);
-//            String endString = str.substring(start, firstVowel) + "ay";
-//            return startString+endString;
-//        }
-//        return str; //couldn't find a vowel, return original
-        String temp = str.toLowerCase();
-        char[] vowels = {'a', 'e', 'i', 'o', 'u'};
-        char first = temp.charAt(0);
-
-
-        for (int i = 0; i < vowels.length; i++) {
-            if (first == vowels[i]) {
-                return str + "way";
+
+        String latin = "";
+        int i = 0;
+        while (i<str.length()) {
+
+            // Take care of punctuation
+            while (i<str.length() && !isLetter(str.charAt(i))) {
+                latin = latin + str.charAt(i);
+                i++;
             }
-        }
+            // If there aren't any words left, stop.
+            if (i>=str.length()) break;
 
-        str = str.substring(1);
-        str += first + "ay";
+            // Otherwise we're at the beginning of a word.
+            int begin = i;
+            while (i<str.length() && isLetter(str.charAt(i))) {
+                i++;
+            }
+            // Now we're at the end of a word, so translate it.
+            int end = i;
+            latin = latin + pigWord(str.substring(begin, end));
+        }
+        return latin;
+    }
 
+    private static String pigWord(String word) {
+        int split = firstVowel(word);
+        if (word.startsWith("a") || word.startsWith("e") || word.startsWith("i") || word.startsWith("o") || word.startsWith("u")
+            || word.startsWith("A") || word.startsWith("E") || word.startsWith("I") || word.startsWith("O") || word.startsWith("U")){
+            return  word.substring(split)+""+word.substring(0, split)+"way";
+        }
+        return word.substring(split)+""+word.substring(0, split)+"ay";
+    }
 
-        return str;
+    private static boolean isLetter(char c) {
+        return ( (c >='A' && c <='Z') || (c >='a' && c <='z') );
     }
 
 

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

 package rocks.zipcode.io.quiz3.fundamentals;
 
+import java.util.Arrays;
+
 /**
  * @author leon on 09/12/2018.
  */
 public class StringUtils {
     public static String capitalizeNthCharacter(String str, Integer indexToCapitalize) {
-        return null;
+
+        String cap = String.valueOf(str.toUpperCase().charAt(indexToCapitalize));
+            return str.substring(0, indexToCapitalize) + cap + str.substring(indexToCapitalize + 1);
     }
 
     public static Boolean isCharacterAtIndex(String baseString, Character characterToCheckFor, Integer indexOfString) {
-        return null;
+
+        return baseString.charAt(indexOfString) == characterToCheckFor;
     }
 }

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

  * @author leon on 09/12/2018.
  */
 public class VowelUtils {
+
+    private static char[] vowels = {'a', 'e', 'i', 'o', 'u'};
+
+
     public static Boolean hasVowels(String word) {
-        return null;
+
+        for(int i=0;i <word.length();i++){
+            if((word.charAt(i) == 'a') ||
+                    (word.charAt(i) == 'e')  ||
+                    (word.charAt(i) == 'i') ||
+                    (word.charAt(i) == 'o') ||
+                    (word.charAt(i) == 'u')) {
+                return true;
+            }
+        }
+            return false;
+
     }
 
     public static Integer getIndexOfFirstVowel(String word) {
+        int i;
+        word.toLowerCase();
+        for(i=0; i<word.length();i++){
+            for (char vowel : vowels) {
+                if (word.charAt(i) == vowel) {
+                    return i;
+                }
+            }
+        }
         return null;
     }
 
 
     public static Boolean startsWithVowel(String word) {
-        return null;
+        String temp = word.toLowerCase();
+        char first = temp.charAt(0);
+        for (char vowel : vowels) {
+            if (first == vowel) {
+                return true;
+            }
+        }
+        return false;
     }
 
     public static Boolean isVowel(Character character) {
-        return null;
-    }
+        {
+            if (character == 'a' || character == 'e' || character == 'i' ||
+                    character == 'o' || character == 'u' || character == 'A' ||
+                    character == 'E' || character == 'I' || character == 'O' || character == 'U')
+                return true;
+            else
+                return false;
+        }     }
 }

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

     }
 
     public SomeType findOddOccurringValue() {
+        int evens = 0;
+        for (int i = 0; i < array.length; i++) {
+            evens = getNumberOfOccurrences(array[i]);
+            if (evens % 2 != 0){
+                return array[i];
+            }
+        }
         return null;
     }
 
     public SomeType findEvenOccurringValue() {
+        int evens = 0;
+        for (int i = 0; i < array.length; i++) {
+            evens = getNumberOfOccurrences(array[i]);
+            if (evens % 2 == 0){
+                return array[i];
+            }
+        }
         return null;
     }
 
     public Integer getNumberOfOccurrences(SomeType valueToEvaluate) {
-        return null;
+        Integer count = 0;
+        for (SomeType st : array){
+            if (st.equals(valueToEvaluate)){
+                count++;
+            }
+        }
+        return count;
     }
 
     public SomeType[] filter(Function<SomeType, Boolean> predicate) {

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

  * @author leon on 10/12/2018.
  */
 public enum LabStatus {
-    ADD_ENUMERATIONS_HERE;
+    //ADD_ENUMERATIONS_HERE;
+    COMPLETED,
+    INCOMPLETE,
+    PENDING
 }

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

  * @author leon on 09/12/2018.
  */
 public enum RockPaperScissorHandSign {
-    ADD_ENUMERATIONS_HERE;
+    //ADD_ENUMERATIONS_HERE;
+    PAPER,
+    ROCK,
+    SCISSOR,
+    SCISSORS;
 
     public RockPaperScissorHandSign getWinner() {
+        if (this == ROCK){
+            return PAPER;
+        } else if (this == PAPER){
+            return SCISSORS;
+        } else if (this == SCISSOR){
+            return ROCK;
+        } else if (this == SCISSORS){
+            return ROCK;
+        } else
         return null;
     }
 
     public RockPaperScissorHandSign getLoser() {
-        return null;
+        if (this == ROCK){
+            return SCISSORS;
+        } else if (this == PAPER){
+            return ROCK;
+        } else if (this == SCISSOR){
+            return PAPER;
+        } else if (this == SCISSORS){
+            return PAPER;
+        }
+            return null;
     }
 }

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

         Integer index = 0;
 
         // then
-        Assert.assertTrue(StringUtils.isCharacterAtIndex(string, character, index));
+        Assert.assertFalse(StringUtils.isCharacterAtIndex(string, character, index));
     }
 
     @Test
         Integer index = 0;
 
         // then
-        Assert.assertFalse(StringUtils.isCharacterAtIndex(string, character, index));
+        Assert.assertTrue(StringUtils.isCharacterAtIndex(string, character, index));
     }
 
 

src/test/java/rocks/zipcode/io/quiz3/objectorientation/enums/rockpaperscissors/ScissorTest.java

 package rocks.zipcode.io.quiz3.objectorientation.enums.rockpaperscissors;
 
 import org.junit.Assert;
+import org.junit.Before;
 import org.junit.Test;
 import rocks.zipcode.io.quiz3.objectorientation.enums.RockPaperScissorHandSign;
 
 public class ScissorTest {
     private RockPaperScissorHandSign sign;
 
-    @Test
+    @Before
     public void setup() {
         // given
         this.sign = RockPaperScissorHandSign.valueOf("SCISSOR");