30 minutes left

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

@@ -4,7 +4,22 @@ package rocks.zipcode.io.quiz3.arrays;
  * @author leon on 09/12/2018.
  s*/
 public class SquareArrayAnalyzer {
+
     public static Boolean compare(Integer[] input, Integer[] squaredValues) {
-        return null;
+        Boolean flag = null;
+
+        for (int i = 0; i <input.length ; i++) {
+
+            for (int j = 0; j <squaredValues.length ; j++) {
+
+                if(input[i] == Math.abs(Math.sqrt(squaredValues[j]))){
+                        flag = true;
+                }else{
+                    flag = false;
+                }
+            }
+
+        }
+        return flag;
     }
 }

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

@@ -1,30 +1,90 @@
 package rocks.zipcode.io.quiz3.arrays;
 
+import com.sun.org.apache.xerces.internal.impl.xpath.regex.Match;
+import com.sun.org.apache.xpath.internal.operations.Bool;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
 /**
  * @author leon on 09/12/2018.
  */
 public class TicTacToe {
 
+    private String[][] tictac;
+
     public TicTacToe(String[][] board) {
+        this.tictac = board;
     }
 
     public String[] getRow(Integer value) {
-        return null;
+
+        ArrayList<String> rows = new ArrayList<>();
+
+        for (int i = value; i <= value ; i++) {
+
+            for (int j = 0; j < tictac.length ; j++) {
+               rows.add(tictac[i][j]);
+            }
+        }
+
+        String[] rowingArrays = new String[rows.size()];
+        rowingArrays = rows.toArray(rowingArrays);
+        return rowingArrays;
     }
 
     public String[] getColumn(Integer value) {
-        return null;
-    }
 
+        String [] arr = new String[tictac.length];
+        for (int i = 0; i <= tictac.length-1 ; i++) {
+
+                arr[i] = tictac[i][value];
+
+
+
+        }
+        return arr;
+    }
+        //Homongenous means of the same type;
     public Boolean isRowHomogenous(Integer rowIndex) {
-        return null;
+        String [] gettingrow = getRow(rowIndex);
+
+        Boolean match = Arrays.stream(gettingrow).allMatch(s -> s.equals(gettingrow[0]));
+
+        return match;
     }
 
     public Boolean isColumnHomogeneous(Integer columnIndex) {
-        return null;
+
+        String [] gettingColumn = getColumn(columnIndex);
+
+        Boolean match = Arrays.stream(gettingColumn).allMatch(s -> s.equals(gettingColumn[0]));
+
+        return match;
     }
 
-    public String getWinner() {
-        return null;
+    public String getWinner()
+    {
+        String winner = "";
+
+        int counter = 0;
+        int counting = 0;
+
+        for (int i = 0; i < tictac.length ; i++) {
+            for (int j = 0; j < tictac.length ; j++) {
+
+                if (tictac[i][j].equals("X")){
+                    counter++;
+                }else if(tictac[i][j].equals("O")){
+                   counting ++;
+                }
+            }
+            if(counter == 3){
+                winner = "X";
+            }else if(counting == 3){
+                winner = "O";
+            }
+        }
+        return winner;
     }
 }

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

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

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 static String name;
+
     public Lab() {
-        this(null);
+        this(name);
     }
 
     public Lab(String labName) {
+        name =labName;
     }
 
     public String getLabStatus() {
-        return null;
+
+        return name;
     }
 
     public void setLabStatus(String labStatus) {
+       name =labStatus;
     }
 
     public String getName() {
-        return null;
+        return name;
     }
 }

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

@@ -8,21 +8,38 @@ import java.util.Map;
  * @author leon on 10/12/2018.
  */
 public class Student {
-    public Student() {
-        this(null);
+
+
+    private static Map<Lab,LabStatus> map;
+
+    public Student(){
+
+        this(map);
     }
 
     public Student(Map<Lab, LabStatus> map) {
+
+        this.map = map;
+
     }
 
+
+
     public void setLabStatus(Lab lab, LabStatus labStatus) {
+        map.getOrDefault(lab,labStatus);
     }
 
 
     public void forkLab(Lab lab) {
+        map.get(lab);
     }
 
-    public LabStatus getLabStatus(String labName) {
-        throw new UnsupportedOperationException("Method not yet implemented");
+    public LabStatus getLabStatus(String labName) throws UnsupportedOperationException {
+        try {
+            map.containsKey(labName);
+        } catch (UnsupportedOperationException uoe) {
+            throw new UnsupportedOperationException("Method not yet implemented");
+        }
+        return LabStatus.valueOf(labName);
     }
 }

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

@@ -1,10 +1,26 @@
 package rocks.zipcode.io.quiz3.fundamentals;
 
+import java.util.Arrays;
+
 /**
  * @author leon on 09/12/2018.
  */
 public class PigLatinGenerator {
+    private static final char[] vowels = {'a','e','i','o','u'};
     public String translate(String str) {
-        return null;
+        String newWord = "";
+
+//       if(str.startsWith("a") || str.startsWith("e") ||str.startsWith("i")
+//               ||str.startsWith("o") ||str.startsWith("u")){
+//          return newWord = str += "way";
+//
+//       }else if(!str.startsWith("a")|| !str.startsWith("e") ||!str.startsWith("i")
+//               ||!str.startsWith("o") ||!str.startsWith("u")){
+//
+//            return newWord = str.substring(1) + str.charAt(0)  + "ay";
+//       }else{
+//           return newWord;
+//       }
+        
     }
 }

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

@@ -1,14 +1,33 @@
 package rocks.zipcode.io.quiz3.fundamentals;
 
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
 /**
  * @author leon on 09/12/2018.
  */
 public class StringUtils {
     public static String capitalizeNthCharacter(String str, Integer indexToCapitalize) {
-        return null;
+
+       char[] arr = str.toCharArray();
+
+       arr[indexToCapitalize] = Character.toUpperCase(arr[indexToCapitalize]);
+       String str2 = new String(arr);
+       return str2;
     }
 
     public static Boolean isCharacterAtIndex(String baseString, Character characterToCheckFor, Integer indexOfString) {
-        return null;
+
+        Boolean flag;
+        if(baseString.length() ==0)
+            return false;
+
+        if(baseString.charAt(indexOfString) == characterToCheckFor){
+            flag = true;
+        }else{
+            flag = false;
+        }
+
+        return flag;
     }
 }

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

@@ -1,23 +1,58 @@
 package rocks.zipcode.io.quiz3.fundamentals;
 
+import com.sun.org.apache.xpath.internal.operations.Bool;
+
 /**
  * @author leon on 09/12/2018.
  */
 public class VowelUtils {
+    private static final char[] vowels = {'a','e','i','o','u','A','E','I','O','U'};
+
     public static Boolean hasVowels(String word) {
-        return null;
+        return word.matches("[aeiou]");
+
     }
 
     public static Integer getIndexOfFirstVowel(String word) {
+
+        final String vowel = "aeiou";
+
+        for (int i = 0; i < word.length(); i++) {
+            if(vowel.contains(String.valueOf(word.charAt(i))))
+            {
+                return i;
+            }
+        }
         return null;
     }
 
 
     public static Boolean startsWithVowel(String word) {
-        return null;
+
+        Boolean flag = null;
+        String smallword = word.toLowerCase();
+
+        for (int i = 0; i <vowels.length ; i++) {
+            if(smallword.charAt(0) == vowels[i]){
+                return true;
+            }else{
+                flag = false;
+            }
+        }
+        return flag;
     }
 
     public static Boolean isVowel(Character character) {
-        return null;
+
+        Boolean flag = null;
+
+        for (int i = 0; i <vowels.length ; i++) {
+            if(character == vowels[i]){
+                return true;
+            }else{
+                flag = false;
+            }
+        }
+        return flag;
     }
 }

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

@@ -1,5 +1,9 @@
 package rocks.zipcode.io.quiz3.generics;
 
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 import java.util.function.Function;
 
 /**
@@ -9,22 +13,59 @@ public class ArrayUtility<SomeType> {
     private final SomeType[] array;
 
     public ArrayUtility(SomeType[] array) {
+
         this.array = array;
     }
 
     public SomeType findOddOccurringValue() {
-        return null;
+
+        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 SomeType findEvenOccurringValue() {
+        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;
+        Integer count =0;
+
+        for (int i = 0; i < array.length ; i++) {
+
+            if(array[i] == valueToEvaluate) count ++;
+
+        }
+        return  count;
     }
 
     public SomeType[] filter(Function<SomeType, Boolean> predicate) {
-        return null;
+
+       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;
+                COMPLETED,
+               INCOMPLETE,
+               PENDING;
 }

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

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

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