Complete

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

@@ -1,22 +1,32 @@
 package rocks.zipcode.quiz4.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;
+        String[] result = new String [values.length-1];
+        int count = 0;
+        for(String element : values) {
+            if(!element.equals(getMiddleElement((values)))) {
+                result[count] = element;
+                count++;
+            }
+        }
+        return result;
     }
 
     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/quiz4/collections/WordCounter.java

@@ -1,12 +1,22 @@
 package rocks.zipcode.quiz4.collections;
 
+import java.util.HashMap;
 import java.util.Map;
 
 public class WordCounter {
+    private Map<String, Integer> map = new HashMap<>();
     public WordCounter(String... strings) {
+        for(String str : strings){
+            if(map.get(str) != null){
+                Integer value = map.get(str);
+                value++;
+                map.replace(str, value);
+            }else{
+                map.put(str, 1);
+            }
+        }
     }
-
     public Map<String, Integer> getWordCountMap() {
-        return null;
+        return map;
     }
-}
+}

src/main/java/rocks/zipcode/quiz4/collections/culonary/Curry.java

@@ -1,4 +1,10 @@
 package rocks.zipcode.quiz4.collections.culonary;
 
-public class Curry {
+public class Curry implements Spice {
+    @Override
+    public String getName() {
+        return "Curry";
+    }
 }
+
+

src/main/java/rocks/zipcode/quiz4/collections/culonary/Food.java

@@ -1,20 +1,36 @@
 package rocks.zipcode.quiz4.collections.culonary;
 
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 /**
  * @author leon on 27/12/2018.
  */
 public class Food {
+    private Map<Class<? extends Spice>, Integer> spiceMap;
+    private List<Spice> spiceList;
+
+    public Food() {
+        spiceMap = new HashMap<>();
+        spiceList = new ArrayList<>();
+    }
+
     public List<Spice> getAllSpices() {
-        return null;
+        return spiceList;
     }
 
-    public <SpiceType extends Class<? extends Spice>> Map<SpiceType, Integer> getSpiceCount() {
-        return null;
+    public Map<Class<? extends Spice>, Integer> getSpiceCount() {
+        return spiceMap;
     }
 
     public void applySpice(Spice spice) {
+        spiceList.add(spice);
+
+        if(!spiceMap.containsKey((spice.getClass()))){
+            spiceMap.put(spice.getClass(), 1);
+        } else {
+            Integer newAmount = spiceMap.get(spice.getClass());
+            spiceMap. put(spice.getClass(), newAmount + 1);
+        }
     }
 }
+

src/main/java/rocks/zipcode/quiz4/collections/culonary/Ginger.java

@@ -3,5 +3,10 @@
 /**
  * @author leon on 27/12/2018.
  */
-public class Ginger {
+public class Ginger implements Spice {
+
+    @Override
+    public String getName() {
+        return null;
+    }
 }

src/main/java/rocks/zipcode/quiz4/collections/culonary/Pepper.java

@@ -3,5 +3,11 @@
 /**
  * @author leon on 27/12/2018.
  */
-public class Pepper {
+public class Pepper implements Spice{
+
+    @Override
+    public String getName() {
+        return null;
+    }
 }
+

src/main/java/rocks/zipcode/quiz4/collections/culonary/Spice.java

@@ -4,4 +4,6 @@
  * @author leon on 27/12/2018.
  */
 public interface Spice {
+
+String getName();
 }

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

@@ -5,31 +5,38 @@
  */
 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/quiz4/fundamentals/StringUtils.java

@@ -1,34 +1,83 @@
 package rocks.zipcode.quiz4.fundamentals;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+
 /**
  * @author leon on 21/12/2018.
  */
 public class StringUtils {
     public static Character getMiddleCharacter(String string) {
-        return null;
+        if (string.length() % 2 == 0) {
+            return string.charAt((string.length() / 2) - 1);
+        } else {
+            return string.charAt(string.length() / 2);
+        }
     }
 
     public static String capitalizeMiddleCharacter(String str) {
-        return null;
+        String result = "";
+        result = getMiddleCharacter(str).toString().toUpperCase();
+
+        return str.substring(0, str.length() / 2) + result + str.substring((str.length() / 2 + 1));
     }
 
     public static String lowerCaseMiddleCharacter(String str) {
-        return null;
+        String result = "";
+        result = getMiddleCharacter(str).toString().toLowerCase();
+        return str.substring(0, str.length() / 2) + result + str.substring((str.length() / 2 + 1));
     }
 
     public static Boolean isIsogram(String str) {
-        return null;
+        char[] array = str.toCharArray();
+        Arrays.sort(array);
+
+        for (int i = 0; i < array.length - 1; i++)
+            if (array[i] == array[i + 1])
+                return false;
+
+        return true;
     }
+        /*for (int i = 0; i < str.length() - 1; i++) {
+            for (int j = 0; 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;
+        String output = "";
+
+        if (str.charAt(0) != str.charAt(1)) output += str.charAt(0);
+
+        for (int i = 1; i < str.length() - 1; i++) {
+            if (str.charAt(i) != str.charAt(i + 1) && str.charAt(i) != str.charAt(i - 1)) output += str.charAt(i);
+        }
+
+        if (str.charAt(str.length() - 1) != str.charAt(str.length() - 2)) output += str.charAt(str.length() - 1);
+        return output;
     }
 
     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/quiz4/objectorientation/account/Account.java

@@ -3,11 +3,22 @@
 /**
  * @author leon on 30/12/2018.
  */
-public class Account extends BankAccount {
-    public Long getId() {
-        return null;
-    }
+public class Account  {
+
+        Long id;
+
+        public Account() {
+        }
+
+        public Account(Long id) {
+            this.id = id;
+        }
+
+        public Long getId() {
+            return id;
+        }
 
-    public void setId(Long id) {
+        public void setId(Long id) {
+            this.id = id;
+        }
     }
-}

src/main/java/rocks/zipcode/quiz4/objectorientation/account/Bank.java

@@ -1,17 +1,21 @@
 package rocks.zipcode.quiz4.objectorientation.account;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * @author leon on 27/12/2018.
  */
 public class Bank {
-    public BankAccount removeBankAccountByIndex(Integer indexNumber) {
-        return null;
-    }
+        private List<BankAccount> accounts = new ArrayList<>();
 
-    public void addBankAccount(BankAccount bankAccount) {
-    }
+        public BankAccount removeBankAccountByIndex(int indexNumber) { return accounts.remove(indexNumber); }
+
+        public void addBankAccount(BankAccount bankAccount) {
+            accounts.add(bankAccount);
+        }
 
-    public Boolean containsBankAccount(BankAccount bankAccount) {
-        throw new UnsupportedOperationException("Method not yet implemented");
+        public Boolean containsBankAccount(BankAccount bankAccount) {
+            return accounts.contains(bankAccount);
+        }
     }
-}

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

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