src/main/java/rocks/zipcode/quiz5/arrays/ArrayUtils.java

@@ -1,22 +1,28 @@
 package rocks.zipcode.quiz5.arrays;
 
+import java.util.Arrays;
+
 /**
  * @author leon on 01/01/2019.
  */
 public class ArrayUtils {
     public static String getMiddleElement(String[] values) {
-        return null;
+        return values[values.length/2];
     }
 
     public static String[] removeMiddleElement(String[] values) {
-        return null;
+        int x = (values.length - 1) / 2;
+        String[] copy = new String[x * 2];
+        System.arraycopy(values, 0, copy, 0, x);
+        System.arraycopy(values, values.length - x, copy, x, x);
+        return copy;
     }
 
     public static String getLastElement(String[] values) {
-        return null;
+        return values[values.length-1];
     }
 
     public static String[] removeLastElement(String[] values) {
-        return null;
+        return Arrays.copyOf(values, values.length-1);
     }
 }

src/main/java/rocks/zipcode/quiz5/collections/Bank.java

@@ -2,18 +2,29 @@ package rocks.zipcode.quiz5.collections;
 
 import rocks.zipcode.quiz5.objectorientation.account.BankAccount;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * @author leon on 27/12/2018.
  */
 public class Bank {
+    List<BankAccount> bank = new ArrayList<>();
+
     public BankAccount removeBankAccountByIndex(Integer indexNumber) {
-        return null;
+        bank.remove(indexNumber);
+       return null;
     }
 
     public void addBankAccount(BankAccount bankAccount) {
+        bank.add(bankAccount);
     }
 
     public Boolean containsBankAccount(BankAccount bankAccount) {
-        throw new UnsupportedOperationException("Method not yet implemented");
+        if(bank.contains(bankAccount)){
+            return true;
+        }else{
+            return false;
+        }
     }
 }

src/main/java/rocks/zipcode/quiz5/collections/Food.java

@@ -2,6 +2,8 @@ package rocks.zipcode.quiz5.collections;
 
 import rocks.zipcode.quiz5.objectorientation.Spice;
 
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -9,6 +11,8 @@ import java.util.Map;
  * @author leon on 27/12/2018.
  */
 public class Food {
+    Map<Spice, Integer> spices = new HashMap<>();
+
     public List<Spice> getAllSpices() {
         return null;
     }

src/main/java/rocks/zipcode/quiz5/collections/WordCounter.java

@@ -1,12 +1,17 @@
 package rocks.zipcode.quiz5.collections;
 
+import java.util.HashMap;
 import java.util.Map;
 
 public class WordCounter {
+    String[] strings;
+    Map<String, Integer> map = new HashMap<>();
+
     public WordCounter(String... strings) {
+        this.strings = strings;
     }
 
     public Map<String, Integer> getWordCountMap() {
-        return null;
+        return map;
     }
 }

src/main/java/rocks/zipcode/quiz5/fundamentals/Calculator.java

@@ -1,35 +1,46 @@
 package rocks.zipcode.quiz5.fundamentals;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * @author leon on 21/12/2018.
  */
 public class Calculator {
     public static Double squareRoot(Double value) {
-        return null;
+        return Math.sqrt(value);
     }
 
     public static Double square(Double value) {
-        return null;
+        return value*value;
     }
 
     public static Double[] squareRoots(Double... value) {
-        return null;
+        Double[] result = new Double[value.length];
+        for(int i = 0; i < value.length ; i++ )
+            result[i] = Math.sqrt(value[i]);
+
+        return result;
     }
 
     public static Double[] squares(Double... values) {
-        return null;
+        Double[] result = new Double[values.length];
+        for(int i = 0; i < values.length ; i++ )
+            result[i] = values[i]*values[i];
+
+        return result;
     }
 
     public static Double add(Double value1, Double value2) {
-        return null;
+        return value1+value2;
     }
 
     public static Double subtract(Double value1, Double value2) {
-        return null;
+        return value1-value2;
     }
 
 
     public static Double divide(Double divisor, Double dividend) {
-        return null;
+        return divisor/dividend;
     }
 }

src/main/java/rocks/zipcode/quiz5/fundamentals/StringUtils.java

@@ -1,34 +1,127 @@
 package rocks.zipcode.quiz5.fundamentals;
 
+import java.util.Arrays;
+import java.util.Scanner;
+
 /**
  * @author leon on 21/12/2018.
  */
 public class StringUtils {
     public static Character getMiddleCharacter(String string) {
-        return null;
+        return string.charAt(string.length()/2);
     }
 
     public static String capitalizeMiddleCharacter(String str) {
-        return null;
+        char[] arr = str.toCharArray();
+        arr[arr.length/2] = Character.toUpperCase(arr[arr.length/2]);
+        String string = new String(arr);
+        return string;
     }
 
     public static String lowerCaseMiddleCharacter(String str) {
-        return null;
+        char[] arr = str.toCharArray();
+        arr[arr.length/2] = Character.toLowerCase(arr[arr.length/2]);
+        String string = new String(arr);
+        return string;
     }
 
     public static Boolean isIsogram(String str) {
-        return null;
+        int len = str.length();
+
+        char arr[] = str.toCharArray();
+
+        Arrays.sort(arr);
+        for (int i = 0; i < len - 1; i++) {
+            if (arr[i] == arr[i + 1])
+                return false;
+        }
+        return true;
     }
 
+
+
     public static Boolean hasDuplicateConsecutiveCharacters(String str) {
-        return null;
+        for (int i = 1; i <str.length() ; i++) {
+            if (str.charAt(i) == str.charAt(i - 1))
+                return true;
+        }
+        return false;
     }
 
     public static String removeConsecutiveDuplicateCharacters(String str) {
-        return null;
+        if (str == null) {
+            return str;
+        }
+        if (str.length() == 1) {
+            return str;
+        }
+        while ( isValid(str)) {
+            int length = str.length();
+            int firstIndex = 0;
+            boolean findConsecutiveDuplicates = false;
+            int i;
+            for (i = 1; i < length; i++) {
+                if (str.charAt(i) == str.charAt(i - 1)) {
+                    findConsecutiveDuplicates = true;
+                    firstIndex = i + 1;
+                } else {
+                    if (findConsecutiveDuplicates) {
+                        str = str.substring(firstIndex);
+                        break;
+                    }
+                    int prev = i - 1;
+                    StringBuilder sb = new StringBuilder();
+                    while (i < length) {
+                        if (!findConsecutiveDuplicates && str.charAt(prev) != str.charAt(i)) {
+                            sb.append(str.charAt(prev));
+                            prev = i;
+                        } else {
+                            findConsecutiveDuplicates = true;
+                            if (findConsecutiveDuplicates && str.charAt(prev) != str.charAt(i)) {
+                                sb.append(str.substring(i));
+                                break;
+                            }
+                        }
+                        i++;
+                    }
+                    if (!findConsecutiveDuplicates) {
+                        sb.append(str.charAt(i - 1));
+                    }
+                    str = sb.toString();
+                    break;
+                }
+            }
+            if (i == str.length()) {
+                str = str.substring(firstIndex);
+            }
+        }
+        return str;
     }
 
     public static String invertCasing(String str) {
-        return null;
+        char[] chars = str.toCharArray();
+        for (int i = 0; i < chars.length; i++)
+        {
+            char c = chars[i];
+            if (Character.isUpperCase(c))
+            {
+                chars[i] = Character.toLowerCase(c);
+            }
+            else if (Character.isLowerCase(c))
+            {
+                chars[i] = Character.toUpperCase(c);
+            }
+        }
+        return new String(chars);
+    }
+
+    public static boolean isValid(String string) {
+        for (int i = 1; i < string.length(); i++) {
+            if (string.charAt(i - 1) == string.charAt(i)) {
+                return true;
+            }
+        }
+        return false;
     }
+
 }

src/main/java/rocks/zipcode/quiz5/objectorientation/Curry.java

@@ -1,4 +1,5 @@
 package rocks.zipcode.quiz5.objectorientation;
 
-public class Curry {
+
+public class Curry implements Spice {
 }

src/main/java/rocks/zipcode/quiz5/objectorientation/Ginger.java

@@ -3,5 +3,5 @@ package rocks.zipcode.quiz5.objectorientation;
 /**
  * @author leon on 27/12/2018.
  */
-public class Ginger {
+public class Ginger implements Spice {
 }

src/main/java/rocks/zipcode/quiz5/objectorientation/Pepper.java

@@ -3,5 +3,5 @@ package rocks.zipcode.quiz5.objectorientation;
 /**
  * @author leon on 27/12/2018.
  */
-public class Pepper {
+public class Pepper implements Spice{
 }

src/main/java/rocks/zipcode/quiz5/objectorientation/account/Account.java

@@ -3,11 +3,13 @@ package rocks.zipcode.quiz5.objectorientation.account;
 /**
  * @author leon on 30/12/2018.
  */
-public class Account extends BankAccount {
+public class Account extends BankAccount implements Transactable {
+    private long id;
     public Long getId() {
-        return null;
+        return id;
     }
 
     public void setId(Long id) {
+        this.id=id;
     }
 }

src/main/java/rocks/zipcode/quiz5/objectorientation/account/BankAccount.java

@@ -3,7 +3,23 @@ package rocks.zipcode.quiz5.objectorientation.account;
 /**
  * @author leon on 27/12/2018.
  */
-public class BankAccount {
+public class BankAccount implements Transactable {
+    private Double balance;
     public void setBalance(Double val) {
+        this.balance =val;
+    }
+
+    @Override
+    public void deposit(Double amountToIncreaseBy) {
+    }
+
+    @Override
+    public void withdrawal(Double amountToDecreaseBy) {
+
+    }
+
+    @Override
+    public Double getBalance() {
+        return balance;
     }
 }

src/main/java/rocks/zipcode/quiz5/objectorientation/account/Employee.java

@@ -3,18 +3,55 @@ package rocks.zipcode.quiz5.objectorientation.account;
 /**
  * @author leon on 30/12/2018.
  */
-public class Employee {
+public class Employee implements Transactable, Worker {
+    private BankAccount bankAccount;
     public Employee() {
     }
 
     public Employee(BankAccount bankAccount) {
+        this.bankAccount = bankAccount;
     }
 
     public BankAccount getBankAccount() {
-        return null;
+        return bankAccount;
     }
 
     public void setBankAccount(BankAccount bankAccount) {
+        this.bankAccount= bankAccount;
+    }
+
+    @Override
+    public void deposit(Double amountToIncreaseBy) {
+
+    }
+
+    @Override
+    public void withdrawal(Double amountToDecreaseBy) {
+
+    }
+
+    @Override
+    public Double getBalance() {
+        return null;
+    }
 
+    @Override
+    public void increaseHoursWorked(Double numberOfHours) {
+
+    }
+
+    @Override
+    public Double getHoursWorked() {
+        return null;
+    }
+
+    @Override
+    public Double getHourlyWage() {
+        return null;
+    }
+
+    @Override
+    public Double getMoneyEarned() {
+        return null;
     }
 }