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

  */
 public class ArrayUtils {
     public static String getMiddleElement(String[] values) {
-        return null;
+        return values[(values.length-1)/2];
     }
 
     public static String[] removeMiddleElement(String[] values) {
-        return null;
+        String[] values2 = new String[values.length -1];
+        for (int i=0; i<values.length; i++) {
+            if (i < (values.length-1)/2) {
+                values2[i] = values[i];
+            } else if (i > (values.length-1)/2) {
+                values2[i-1] = values[i];
+            }
+        }
+        return values2;
     }
 
     public static String getLastElement(String[] values) {
-        return null;
+        return values[values.length-1];
     }
 
     public static String[] removeLastElement(String[] values) {
-        return null;
+        String[] values2 = new String[values.length -1];
+        for (int i=0; i<values2.length; i++) {
+            values2[i] = values[i];
+        }
+        return values2;
     }
 }

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

 
 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> bankAccounts;
+
+    public Bank(){
+        bankAccounts = new ArrayList<>();
+    }
     public BankAccount removeBankAccountByIndex(Integer indexNumber) {
-        return null;
+        BankAccount b = bankAccounts.get(indexNumber);
+        bankAccounts.remove((int) indexNumber);
+        return b;
     }
 
     public void addBankAccount(BankAccount bankAccount) {
+        bankAccounts.add(bankAccount);
     }
 
     public Boolean containsBankAccount(BankAccount bankAccount) {
-        throw new UnsupportedOperationException("Method not yet implemented");
+        return bankAccounts.contains(bankAccount);
     }
 }

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

 
 import rocks.zipcode.quiz5.objectorientation.Spice;
 
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 /**
  * @author leon on 27/12/2018.
  */
-public class Food {
+public class Food <SpiceType extends Spice> {
+    List<Spice> spices;
+
+    public Food(){
+        spices = new ArrayList<>();
+    }
+
     public List<Spice> getAllSpices() {
-        return null;
+        return spices;
     }
 
     public <SpiceType extends Class<? extends Spice>> Map<SpiceType, Integer> getSpiceCount() {
-        return null;
+        Map<SpiceType, Integer> spiceCount = new HashMap<>();
+        spices.forEach((spice) -> {
+            if (!spiceCount.containsKey(spice.getClass()))
+                spiceCount.put((SpiceType) spice.getClass(), 1);
+            else
+                spiceCount.put((SpiceType) spice.getClass(), spiceCount.get(spice.getClass()) + 1);
+        });
+        return spiceCount;
     }
 
     public void applySpice(Spice spice) {
+        spices.add(spice);
     }
 }

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

 package rocks.zipcode.quiz5.collections;
 
+import java.util.HashMap;
 import java.util.Map;
 
 public class WordCounter {
+    String[] strings;
+
     public WordCounter(String... strings) {
+        this.strings = strings;
     }
 
     public Map<String, Integer> getWordCountMap() {
-        return null;
+        Map<String, Integer> map = new HashMap<>();
+        for (int i=0; i<strings.length; i++) {
+            String str = strings[i];
+            if (!map.containsKey(str)) map.put(str, 1);
+            else map.put(str,map.get(str) +1);
+        }
+        return map;
     }
 }

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

  */
 public class Calculator {
     public static Double squareRoot(Double value) {
-        return null;
+        return Math.sqrt(value);
     }
 
     public static Double square(Double value) {
-        return null;
+        return round(value * value);
     }
 
     public static Double[] squareRoots(Double... value) {
-        return null;
+        Double[] sqrts = new Double[value.length];
+        for (int i=0; i<sqrts.length; i++)
+            sqrts[i] = squareRoot(value[i]);
+        return sqrts;
     }
 
     public static Double[] squares(Double... values) {
-        return null;
+        Double[] sqrts = new Double[values.length];
+        for (int i=0; i<sqrts.length; i++)
+            sqrts[i] = square(values[i]);
+        return sqrts;
     }
 
     public static Double add(Double value1, Double value2) {
-        return null;
+        return round(value1 + value2);
     }
 
     public static Double subtract(Double value1, Double value2) {
-        return null;
+        return round(value1 - value2);
     }
 
 
     public static Double divide(Double divisor, Double dividend) {
-        return null;
+        return divisor/dividend;
+    }
+
+    private static Double round(Double value) {
+        return Math.round(value *10000.0)/10000.0;
     }
 }

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

  */
 public class StringUtils {
     public static Character getMiddleCharacter(String string) {
-        return null;
+        return string.charAt((string.length()-1)/2);
     }
 
     public static String capitalizeMiddleCharacter(String str) {
-        return null;
+        int middle = (str.length()-1)/2;
+        return str.substring(0,middle)
+                + str.substring(middle, middle+1).toUpperCase()
+                + str.substring(middle+1);
     }
 
     public static String lowerCaseMiddleCharacter(String str) {
-        return null;
+        int middle = (str.length()-1)/2;
+        return str.substring(0,middle)
+                + str.substring(middle, middle+1).toLowerCase()
+                + str.substring(middle+1);
     }
 
     public static Boolean isIsogram(String str) {
-        return null;
+        for (int i=0; i<str.length(); i++) {
+            for (int j=i+1; j<str.length(); j++)
+                if (str.charAt(i) == str.charAt(j))
+                    return false;
+        }
+        return true;
     }
 
     public static Boolean hasDuplicateConsecutiveCharacters(String str) {
-        return null;
+        for (int i=0; i<str.length()-1; i++) {
+            if (str.charAt(i) == str.charAt(i+1))
+                return true;
+        }
+        return false;
     }
 
     public static String removeConsecutiveDuplicateCharacters(String str) {
-        return null;
+        StringBuilder sb = new StringBuilder(str.substring(0,1));
+        for (int i=1; i<str.length(); i++)
+            if (str.charAt(i) != str.charAt(i-1))
+                sb.append(str.charAt(i));
+            else sb.deleteCharAt(sb.length()-1);
+        return sb.toString();
     }
 
     public static String invertCasing(String str) {
-        return null;
+        StringBuilder sb = new StringBuilder();
+        for (int i=0; i<str.length(); i++) {
+            if (Character.isUpperCase(str.charAt(i))) sb.append(Character.toLowerCase(str.charAt(i)));
+            else sb.append(Character.toUpperCase(str.charAt(i)));
+        }
+        return sb.toString();
     }
 }

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

 package rocks.zipcode.quiz5.objectorientation;
 
-public class Curry {
+public class Curry implements Spice {
 }

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

 /**
  * @author leon on 27/12/2018.
  */
-public class Ginger {
+public class Ginger implements Spice {
 }

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

 /**
  * @author leon on 27/12/2018.
  */
-public class Pepper {
+public class Pepper implements Spice {
 }

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

 /**
  * @author leon on 30/12/2018.
  */
-public class Account extends BankAccount {
+public class Account{
+    Double balance;
+    Long id;
+
+    public Account() {
+        this.balance = 0.0;
+    }
     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

 /**
  * @author leon on 27/12/2018.
  */
-public class BankAccount {
+public class BankAccount extends Account implements Transactable {
+
     public void setBalance(Double val) {
+        this.balance = val;
+    }
+
+    @Override
+    public void deposit(Double amountToIncreaseBy) {
+        if (amountToIncreaseBy < 0) throw new IllegalArgumentException();
+        this.balance += amountToIncreaseBy;
+    }
+
+    @Override
+    public void withdrawal(Double amountToDecreaseBy) {
+        if (amountToDecreaseBy <= 0 || amountToDecreaseBy > this.balance) throw new IllegalArgumentException();
+        this.balance -= amountToDecreaseBy;
+    }
+
+    @Override
+    public Double getBalance() {
+        return this.balance;
     }
 }

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

 /**
  * @author leon on 30/12/2018.
  */
-public class Employee {
+public class Employee implements Worker, Transactable {
+    private BankAccount bankAccount;
+    private Double hoursWorked;
+    private Double hourlyWage;
+
     public Employee() {
+        this.bankAccount = new BankAccount();
+        this.hoursWorked = 0.0;
+        this.hourlyWage = 35.0;
     }
 
     public Employee(BankAccount bankAccount) {
+        this.bankAccount = bankAccount;
+        this.hoursWorked = 0.0;
+        this.hourlyWage = 35.0;
     }
 
     public BankAccount getBankAccount() {
-        return null;
+        return bankAccount;
     }
 
     public void setBankAccount(BankAccount bankAccount) {
+        this.bankAccount = bankAccount;
+    }
+
+    @Override
+    public void increaseHoursWorked(Double numberOfHours) {
+        hoursWorked += numberOfHours;
+    }
+
+    @Override
+    public Double getHoursWorked() {
+        return hoursWorked;
+    }
+
+    @Override
+    public Double getHourlyWage() {
+        return hourlyWage;
+    }
+
+    @Override
+    public Double getMoneyEarned() {
+        return hourlyWage * hoursWorked;
+    }
+
+    @Override
+    public void deposit(Double amountToIncreaseBy) {
+        this.bankAccount.deposit(amountToIncreaseBy);
+    }
+
+    @Override
+    public void withdrawal(Double amountToDecreaseBy) {
+        this.bankAccount.withdrawal(amountToDecreaseBy);
+    }
 
+    @Override
+    public Double getBalance() {
+        return this.bankAccount.getBalance();
     }
 }