complete

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

@@ -5,18 +5,34 @@
  */
 public class ArrayUtils {
     public static String getMiddleElement(String[] values) {
-        return null;
+        int len = values.length;
+        return values[len/2];
     }
 
     public static String[] removeMiddleElement(String[] values) {
-        return null;
+        String[] newArray = new String[values.length - 1];
+        int count = 0;
+        for(String letter : values){
+            if(letter.equals(getMiddleElement(values))){
+                continue;
+            }
+            else{
+                newArray[count] = letter;
+                count++;
+            }
+        }
+        return newArray;
     }
 
     public static String getLastElement(String[] values) {
-        return null;
+        return values[values.length-1];
     }
 
     public static String[] removeLastElement(String[] values) {
-        return null;
+        String[] newArray = new String[values.length - 1];
+        for(int i = 0; i < newArray.length; i++){
+            newArray[i] = values[i];
+        }
+        return newArray;
     }
 }

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

@@ -1,12 +1,24 @@
 package rocks.zipcode.quiz4.collections;
 
+import java.util.HashMap;
 import java.util.Map;
 
 public class WordCounter {
+    Map<String, Integer> wordMap = new HashMap<>();
     public WordCounter(String... strings) {
+        for(String word : strings){
+            Integer count = wordMap.get(word);
+            if(count == null){
+                wordMap.put(word, 1);
+            }
+            else{
+                wordMap.put(word, wordMap.get(word) + 1);
+            }
+        }
     }
 
     public Map<String, Integer> getWordCountMap() {
-        return null;
+
+        return wordMap;
     }
 }

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,27 @@
 package rocks.zipcode.quiz4.collections.culonary;
 
+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 {
+    List<Spice> spices = new ArrayList<>();
     public List<Spice> getAllSpices() {
-        return null;
+
+        return this.spices;
     }
 
     public <SpiceType extends Class<? extends Spice>> Map<SpiceType, Integer> getSpiceCount() {
-        return null;
+        Map<SpiceType, Integer> spiceMap = new HashMap<>();
+        spiceMap.put((SpiceType) spices.get(0).getClass(), spices.size());
+        return spiceMap;
     }
 
     public void applySpice(Spice spice) {
+        this.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,62 @@
 package rocks.zipcode.quiz4.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;
+        List<Double> newArray2 = new ArrayList<>();
+        int count = 0;
+        for(Double number : value){
+            newArray2.add(squareRoot(number));
+        }
+        int len = newArray2.size();
+        Double[] newArray = new Double[len];
+        for(Double element : newArray2){
+            newArray[count] = element;
+            count++;
+        }
+        return newArray;
     }
 
     public static Double[] squares(Double... values) {
-        return null;
+        List<Double> newArray2 = new ArrayList<>();
+        int count = 0;
+        for(Double number : values){
+            newArray2.add(square(number));
+        }
+        int len = newArray2.size();
+        Double[] newArray = new Double[len];
+        for(Double element : newArray2){
+            newArray[count] = element;
+            count++;
+        }
+        return newArray;
     }
 
     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,113 @@
 package rocks.zipcode.quiz4.fundamentals;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
 /**
  * @author leon on 21/12/2018.
  */
 public class StringUtils {
     public static Character getMiddleCharacter(String string) {
-        return null;
+        String[] newArray = string.split("");
+        Integer middle = newArray.length/2;
+        return string.charAt(middle);
     }
 
     public static String capitalizeMiddleCharacter(String str) {
-        return null;
+        String newString = "";
+        String[] newArray = str.split("");
+        Integer middle = newArray.length/2;
+        int count = 0;
+        for(String letter : newArray){
+            if(count == middle){
+                newString += getMiddleCharacter(str).toString().toUpperCase();
+            }
+            else{
+                newString += letter;
+            }
+            count++;
+        }
+        return newString;
     }
 
     public static String lowerCaseMiddleCharacter(String str) {
-        return null;
+        String newString = "";
+        String[] newArray = str.split("");
+        Integer middle = newArray.length/2;
+        int count = 0;
+        for(String letter : newArray){
+            if(count == middle){
+                newString += getMiddleCharacter(str).toString().toLowerCase();
+            }
+            else{
+                newString += letter;
+            }
+            count++;
+        }
+        return newString;
     }
 
     public static Boolean isIsogram(String str) {
-        return null;
+        String[] newArray = str.split("");
+        List<String> newArray2 = new ArrayList<String>();
+        newArray2.addAll(Arrays.asList(newArray));
+        for(int i = 0; i < newArray2.size(); i++){
+            if(Collections.frequency(newArray2, newArray2.get(i)) > 1){
+                return false;
+            }
+        }
+        return true;
     }
 
     public static Boolean hasDuplicateConsecutiveCharacters(String str) {
-        return null;
+        String[] newArray = str.split("");
+        for(int i = 0; i < newArray.length; i++){
+            if( i == (newArray.length - 1)){
+                break;
+            }
+            else if (newArray[i].equals(newArray[i + 1])){
+                    return true;
+                }
+            }
+
+        return false;
     }
 
     public static String removeConsecutiveDuplicateCharacters(String str) {
-        return null;
+        String[] newArray = str.split("");
+        String newString = "";
+        for(int i = 0; i < newArray.length; i++){
+            if(i == (newArray.length-1) && (newArray[newArray.length - 1] != newArray[newArray.length - 2])){
+                newString += newArray[i];
+            }
+            else if(i == (newArray.length-1)){
+                break;
+            }
+            else if(newArray[i].equals(newArray[i+1])){
+                i++;
+            }
+            else if(!newArray[i].equals(newArray[i+1])){
+                newString += newArray[i];
+            }
+        }
+
+        return newString;
     }
 
     public static String invertCasing(String str) {
-        return null;
+        String newString = "";
+        String[] newArray = str.split("");
+        for(int i = 0; i < newArray.length; i++){
+            if(newArray[i].toUpperCase().equals(newArray[i])){
+                newString += newArray[i].toLowerCase();
+            }
+            else{
+                newString += newArray[i].toUpperCase();
+            }
+        }
+
+        return newString;
     }
 }

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

@@ -3,11 +3,13 @@
 /**
  * @author leon on 30/12/2018.
  */
-public class Account extends BankAccount {
+public class Account {
+    private Long id;
     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,25 @@
 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;
+    List<BankAccount> allAccounts = new ArrayList<>();
+    public void removeBankAccountByIndex(Integer indexNumber) {
+        int number = indexNumber;
+        allAccounts.remove(number);
+
     }
 
     public void addBankAccount(BankAccount bankAccount) {
+        allAccounts.add(bankAccount);
     }
 
     public Boolean containsBankAccount(BankAccount bankAccount) {
-        throw new UnsupportedOperationException("Method not yet implemented");
+
+        return allAccounts.contains(bankAccount);
     }
 }

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

@@ -3,7 +3,38 @@
 /**
  * @author leon on 27/12/2018.
  */
-public class BankAccount {
+public class BankAccount extends Account implements Transactable {
+    private Double balance = 0.0;
     public void setBalance(Double val) {
+        this.balance = val;
+    }
+
+    @Override
+    public void deposit(Double amountToIncreaseBy) {
+        if(amountToIncreaseBy < 0){
+            throw new IllegalArgumentException("Deposit must be positive");
+        }
+        else {
+            this.balance += amountToIncreaseBy;
+        }
+
+    }
+
+    @Override
+    public void withdrawal(Double amountToDecreaseBy) {
+        if(amountToDecreaseBy < 0){
+            throw new IllegalArgumentException("Withdrawal must be positive");
+        }
+        else if(amountToDecreaseBy > balance){
+            throw new IllegalArgumentException("Withdrawal amount is greater than balance");
+        }
+        else {
+            this.balance -= amountToDecreaseBy;
+        }
+    }
+
+    @Override
+    public Double getBalance() {
+        return this.balance;
     }
 }