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

  */
 public class SquareArrayAnalyzer {
     public static Boolean compare(Integer[] input, Integer[] squaredValues) {
-        return null;
+
+        for (Integer i : input)
+            for (Integer j : squaredValues)
+                if (i * i == j)
+                    return true;
+
+        return false;
+
     }
 }

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

 package rocks.zipcode.io.quiz3.arrays;
 
+import java.util.stream.IntStream;
+
 /**
  * @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;
+
+        String [] row = board[value];
+
+        return row;
+
     }
 
     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 [] row =getRow(rowIndex);
+
+        for(int i = 0; i < row.length; i++)
+            if(row[i] == row[i])
+                return true;
+
+
+        return false;
     }
 
     public Boolean isColumnHomogeneous(Integer columnIndex) {
-        return null;
+
+        String[] column = getColumn(columnIndex);
+
+        for(int i = 0; i < column.length; i++)
+            if(column[i] == column[i])
+                return true;
+
+            return false;
     }
 
     public String getWinner() {
-        return null;
+
+        String winner = "";
+        for(int row =0; row< board.length; row++){
+            for(int column = 0; row < board[row].length; column++){
+                if(isRowHomogenous(row) == true && isColumnHomogeneous(column) ){
+                   winner = board[row] [column];
+
+
+                }
+            }
+        }
+
+//         if(isRowHomogenous(0) == true || isRowHomogenous(0) == true)
+//             return String.valueOf(i);
+        return winner;
     }
 }

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.stream.IntStream;
+
 /**
  * @author leon on 09/12/2018.
  */
 public class WaveGenerator {
     public static String[] wave(String str) {
+        //String repeated
+       StringBuilder sb = new StringBuilder(str);
+
+       for(int i = 0; i < 7; i++)
+           sb.append(str);
+
+
+
         return null;
     }
 }

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

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

  */
 public class PigLatinGenerator {
     public String translate(String str) {
-        return null;
+
+       return null;
     }
-}
+
+
+
+
+    }
+

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

  */
 public class StringUtils {
     public static String capitalizeNthCharacter(String str, Integer indexToCapitalize) {
-        return null;
-    }
+  char[] arr = str.toCharArray();
+  arr[indexToCapitalize] = Character.toUpperCase(arr[indexToCapitalize]);
+
+  String newStr = new String(arr);
+
+     return newStr;
+          }
+
+
 
     public static Boolean isCharacterAtIndex(String baseString, Character characterToCheckFor, Integer indexOfString) {
-        return null;
+
+        String newStr = baseString.toLowerCase();
+
+
+       if(newStr.charAt(indexOfString) != characterToCheckFor)
+           return false;
+
+        return true;
     }
 }

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

  */
 public class VowelUtils {
     public static Boolean hasVowels(String word) {
-        return null;
+        String vowels = "aeiou";
+
+       for(int i = 0; i < word.length();i++)
+           for(int j = 0; j < vowels.length(); j++)
+               if(word.charAt(i) == vowels.charAt(j))
+                   return  true;
+               return false;
+
+        //return null;
     }
 
     public static Integer getIndexOfFirstVowel(String word) {
-        return null;
+        String vowels = "aeiou";
+        String wordLowerCase = word.toLowerCase();
+
+        for (int i = 0; i < wordLowerCase.length(); i++)
+            if(vowels.contains(String.valueOf(wordLowerCase.charAt(i)))){
+                return i;
+            }
+
+            return null;
     }
 
 
     public static Boolean startsWithVowel(String word) {
-        return null;
+       Integer firstVowelIndex = getIndexOfFirstVowel(word);
+
+        System.out.println(firstVowelIndex);
+        //for(int i = 0; i < word.length(); i++)
+            if(word.charAt(0) == word.charAt(firstVowelIndex))
+                return true;
+
+        return false;
     }
 
     public static Boolean isVowel(Character character) {
-        return null;
+
+        String charStr = character.toString();
+
+
+
+
+        return startsWithVowel(charStr);
     }
 }

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

     }
 
     public SomeType findOddOccurringValue() {
-        return null;
+
+        for(SomeType type : array)
+            if(getNumberOfOccurrences(type) % 2 != 0)
+      return type;
+
+            return null;
+
     }
 
     public SomeType findEvenOccurringValue() {
+
+        for(SomeType type : array)
+            if(getNumberOfOccurrences(type) % 2 == 0)
+                return type;
+
+
+
         return null;
     }
 
     public Integer getNumberOfOccurrences(SomeType valueToEvaluate) {
-        return null;
+        Integer counter = 0;
+
+        for( SomeType type : array )
+            if(type.equals(valueToEvaluate))
+
+                counter++;
+        return counter;
     }
 
     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;
+    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;
+    PAPER,ROCK, SCISSOR;
+
+    RockPaperScissorHandSign() {
+    }
 
     public RockPaperScissorHandSign getWinner() {
-        return null;
+
+        return SCISSOR;
     }
 
     public RockPaperScissorHandSign getLoser() {
-        return null;
+        return ROCK;
     }
 }

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

                 "aaaAaaa",
                 "aaaaAaa",
                 "aaaaaAa",
-                "aaaaaaA"};
+                "aaaaaaAsimulate "};
 
         // when
         String[] actual = WaveGenerator.wave(input);

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

 
     @Test
     public void testGetWinner() {
-        RockPaperScissorHandSign loser = RockPaperScissorHandSign.valueOf("SCISSORS");
+        RockPaperScissorHandSign loser = RockPaperScissorHandSign.valueOf("SCISSOR");
         Assert.assertEquals(loser, sign.getWinner());
     }
 }

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

 
     @Test
     public void testGetLoser() {
-        RockPaperScissorHandSign loser = RockPaperScissorHandSign.valueOf("SCISSORS");
+        RockPaperScissorHandSign loser = RockPaperScissorHandSign.valueOf("SCISSOR");
         Assert.assertEquals(loser, sign.getLoser());
     }
 

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");