added code

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

 
     public static String[] removeLastElement(String[] values)
     {
-        return null;
+        String str = values[values.length - 1];
+        String[] str1 = new String[values.length-1];
+        for(int i = 0; i<values.length-1;i++)
+        {
+            if(values.equals(str))
+                break;
+            else
+                str1[i] = values[i];
+        }
+
+                return str1;
     }
 }

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

  */
 public class Bank
 {
-    ArrayList<BankAccount> accounts = new ArrayList<>();
-    private int numberOfAccounts;
-
-    public Bank() {
-        numberOfAccounts = 0;
-        accounts = new ArrayList<BankAccount>();
-    }
+    List<BankAccount> accounts = new ArrayList<BankAccount>();
 
     public BankAccount removeBankAccountByIndex(Integer indexNumber)
     {
-       return null;
+       //BankAccount ba = accounts.remove(indexNumber);
+        return null;
     }
 
     public void addBankAccount(BankAccount bankAccount)
 
     public Boolean containsBankAccount(BankAccount bankAccount)
     {
-        throw new UnsupportedOperationException("Method not yet implemented");
+        //throw new UnsupportedOperationException("Method not yet implemented");
+        return accounts.contains(bankAccount);
     }
 }

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

 package rocks.zipcode.quiz5.collections;
 
 import rocks.zipcode.quiz5.objectorientation.Spice;
+import rocks.zipcode.quiz5.objectorientation.account.BankAccount;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
 /**
  * @author leon on 27/12/2018.
  */
-public class Food {
-    public List<Spice> getAllSpices() {
-        return null;
+public class Food implements Spice
+{
+    ArrayList<Spice> food = new ArrayList<Spice>();
+    public List<Spice> getAllSpices()
+    {
+        return food;
+
+        //return (List<Spice>) food.get();
     }
 
-    public <SpiceType extends Class<? extends Spice>> Map<SpiceType, Integer> getSpiceCount() {
+    public <SpiceType extends Class<? extends Spice>> Map<SpiceType, Integer> getSpiceCount()
+    {
         return null;
     }
 
-    public void applySpice(Spice spice) {
+    public void applySpice(Spice spice)
+    {
+        food.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 {
+public class WordCounter
+{
+    Map<String, Integer> map = new HashMap<String, Integer>();
+    String [] strings;
+
     public WordCounter(String... strings) {
+        this.strings = strings;
     }
 
     public Map<String, Integer> getWordCountMap()
     {
-       return null;
+       Map<String,Integer> map = new HashMap<>();
+       for(String s : strings)
+       {
+           if(!map.containsKey(s))
+           {
+               map.put(s,1);
+           }
+           else
+           {
+               int count = map.get(s);
+               map.put(s,count +1);
+           }
+       }
+       return map;
     }
 }

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

         return square;
     }
 
-    public static Double[] squareRoots(Double... value) {
-
-        return null;
-
+    public static Double[] squareRoots(Double... value)
+    {
+        Double[] result = new Double[value.length];
+        for(int i = 0; i<value.length;i++)
+        {
+            result[i] = (Double) Math.sqrt(value[i]);
+        }
+        return result;
     }
 
     public static Double[] squares(Double... values) {
-        List<Double[]> array = new ArrayList<>();//create a List which take an array of int
-
-        Double arr[] = new Double[3];//create a temporary array of 2 elements
-
-        for (int i = 0; i < values.length; i++) {
-             values[i]= (Double) Math.pow(values[i], 2);
-            arr[0] = values[i];//add your number to your array pos 1
-            arr[1] = (Double) Math.pow(values[i], 2);//add the power to the 2ed position
-            array.add(arr);//add your array to your list
+        Double[] result = new Double[values.length];
+        for(int i = 0; i<values.length;i++)
+        {
+            result[i] = values[i]*values[i];
         }
-        return arr;
+        return result;
     }
 
     public static Double add(Double value1, Double value2) {
-        Double val = value1 + value2;
-        double rounded = (double) Math.round(val * 100) / 100;
-        return val;
+        return value1 + value2;
     }
 
     public static Double subtract(Double value1, Double value2) {

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

 
     public static String capitalizeMiddleCharacter(String str)
     {
-        return str.toUpperCase();
+        StringBuilder sb = new StringBuilder(str);
+        int len=str.length()/2;
+        sb.setCharAt(len,Character.toUpperCase(str.charAt(len)));
+        return sb.toString();
 
     }
 
     public static String lowerCaseMiddleCharacter(String str)
     {
-        int len=str.length();
-        int c=len/2;
-        char ch[]=str.toCharArray();
-        return String.valueOf(ch[c]).toLowerCase();
+        StringBuilder sb = new StringBuilder(str);
+        int len=str.length()/2;
+        sb.setCharAt(len,Character.toLowerCase(str.charAt(len)));
+        return sb.toString();
     }
 
-    public static Boolean isIsogram(String str) {
+    public static Boolean isIsogram(String str)
+    {
         String[] ary = str.split("");
         Set<String> mySet = new HashSet<String>(Arrays.asList(ary));
 
     }
 
     public static String removeConsecutiveDuplicateCharacters(String str) {
-        StringBuilder result = new StringBuilder();
-        HashMap<Character, Integer> items = new HashMap<>();
-
-        for (int i = 0; i < str.length(); i++)
+        char[] ch = str.toCharArray();
+        int length = 0;
+        for(int i = 0; i<ch.length ; i++)
         {
-            Character current = str.charAt(i);
-            Integer occurrence = items.get(current);
-            if (occurrence == null)
-                items.put(current, 1);
+            if(length ==0 || ch[i] != ch[length - 1])
+                ch[length++] = ch[i];
             else
-                items.put(current, occurrence + 1);
-        }
-
-        for (int i = 0; i < str.length(); i++)
-        {
-            Character current = str.charAt(i);
-            Integer occurrence = items.get(current);
-            if (occurrence == 1)
-                result.append(current);
+                length--;
         }
-        return result.toString();
+        return new String(ch,0,length);
     }
 
     public static String invertCasing(String str) {