done

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

@@ -1,22 +1,39 @@
 package rocks.zipcode.quiz4.arrays;
 
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
 /**
  * @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;
+        return Stream.of(values)
+                .filter(x -> !x.equals(getMiddleElement(values)))
+                .toArray(String[]::new);
     }
 
     public static String getLastElement(String[] values) {
-        return null;
+        return values[values.length-1];
     }
 
     public static String[] removeLastElement(String[] values) {
-        return null;
+        AtomicInteger i = new AtomicInteger(0);
+        List<String> temp = new LinkedList<>();
+        Arrays.stream(values)
+                .forEach(x -> {
+                    if(i.getAndIncrement() != values.length-1)
+                        temp.add(x);
+                });
+        return temp.toArray(new String[0]);
     }
 }

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

@@ -1,12 +1,18 @@
 package rocks.zipcode.quiz4.collections;
 
+import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.stream.Stream;
 
 public class WordCounter {
+    Stream strigs;
     public WordCounter(String... strings) {
+        strigs = Stream.of(strings);
     }
 
     public Map<String, Integer> getWordCountMap() {
-        return null;
+        Map<String, Integer> retMap = new LinkedHashMap<>();
+        strigs.forEach(x -> retMap.compute((String) x, (k, v) -> (v == null) ? 1 : v + 1));
+        return retMap;
     }
 }

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

@@ -1,4 +1,4 @@
 package rocks.zipcode.quiz4.collections.culonary;
 
-public class Curry {
+public class Curry implements Spice{
 }

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

@@ -1,20 +1,34 @@
 package rocks.zipcode.quiz4.collections.culonary;
 
-import java.util.List;
-import java.util.Map;
+import java.util.*;
+import java.util.stream.Stream;
 
 /**
  * @author leon on 27/12/2018.
  */
 public class Food {
+    List<Spice> spices;
+
+    public Food() {
+        spices = new LinkedList<>();
+    }
+
     public List<Spice> getAllSpices() {
-        return null;
+        return spices;
     }
 
     public <SpiceType extends Class<? extends Spice>> Map<SpiceType, Integer> getSpiceCount() {
-        return null;
+        Map<SpiceType, Integer> retMap = new LinkedHashMap<>();
+        Stream.of(spices)
+                .flatMap(Collection::stream)
+                .forEach(x -> {
+                    retMap.compute((SpiceType)x.getClass(), (k,v) -> (v == null) ? 1 : v + 1);
+                });
+
+        return retMap;
     }
 
     public void applySpice(Spice spice) {
+        spices.add(spice);
     }
 }

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

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

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

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

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

@@ -1,35 +1,42 @@
 package rocks.zipcode.quiz4.fundamentals;
 
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.DoubleStream;
+import java.util.stream.Stream;
+
 /**
  * @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 Math.pow(value, 2);
     }
 
     public static Double[] squareRoots(Double... value) {
-        return null;
+        return Arrays.stream(value).map(Calculator::squareRoot).toArray(Double[]::new);
     }
 
     public static Double[] squares(Double... values) {
-        return null;
+        return Arrays.stream(values).map(Calculator::square).toArray(Double[]::new);
     }
 
     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,86 @@
 package rocks.zipcode.quiz4.fundamentals;
 
+import java.util.*;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
 /**
  * @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;
+        StringBuilder retString = new StringBuilder();
+        AtomicInteger i = new AtomicInteger(0);
+        str.chars().mapToObj(x -> (char)x).forEach(x -> {
+            if((str.length()/2) == i.getAndIncrement())
+                retString.append(x.toString().toUpperCase());
+            else
+                retString.append(x);
+        });
+        return retString.toString();
     }
 
     public static String lowerCaseMiddleCharacter(String str) {
-        return null;
+        StringBuilder retString = new StringBuilder();
+        AtomicInteger i = new AtomicInteger(0);
+        str.chars().mapToObj(x -> (char)x).forEach(x -> {
+            if((str.length()/2) == i.getAndIncrement())
+                retString.append(x.toString().toLowerCase());
+            else
+                retString.append(x);
+        });
+        return retString.toString();
     }
 
     public static Boolean isIsogram(String str) {
-        return null;
+        StringBuilder sorted = new StringBuilder();
+        str.chars().mapToObj(x -> (char)x).sorted().forEach(x -> sorted.append(x));
+        for(int i = 1; i < sorted.length(); i++){
+            if(sorted.charAt(i-1) == sorted.charAt(i))
+                return false;
+        }
+        return true;
     }
 
     public static Boolean hasDuplicateConsecutiveCharacters(String str) {
-        return null;
+        StringBuilder retStr = new StringBuilder();
+        str.chars().mapToObj(x -> (char)x).forEach(x -> retStr.append(x));
+        for(int i = 1; i < retStr.length(); i++){
+            if(retStr.charAt(i-1) == retStr.charAt(i))
+                return true;
+        }
+        return false;
     }
 
     public static String removeConsecutiveDuplicateCharacters(String str) {
-        return null;
+        StringBuilder retStr = new StringBuilder();
+        for(int i = 0; i < str.length()-1; i++){
+            if(str.charAt(i) != str.charAt(i+1))
+                retStr.append(str.charAt(i));
+            else {
+                i++;
+            }
+        }
+        retStr.append(str.charAt(str.length()-1));
+        return retStr.toString();
     }
 
     public static String invertCasing(String str) {
-        return null;
+        StringBuilder retStr = new StringBuilder();
+        str.chars().mapToObj(x -> (char)x)
+                .forEach(x -> {
+                    String cha = x.toString();
+                    if(cha.equals(cha.toUpperCase()))
+                        retStr.append(cha.toLowerCase());
+                    else
+                        retStr.append(cha.toUpperCase());
+                });
+        return retStr.toString();
     }
 }

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

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

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

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

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

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