Finish

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;
+        int mid = values.length / 2;
+        return values[mid];
     }
 
     public static String[] removeMiddleElement(String[] values) {
-        return null;
+        int middleStart = (values.length - 1) / 2;
+        int middleEnd = (values.length - 1) - middleStart;
+        int elementsToRemove = middleEnd - middleStart + 1;
+
+        String[] result = new String[values.length - elementsToRemove];
+        System.arraycopy(values, 0, result, 0, middleStart);
+        System.arraycopy(values, middleEnd + 1, result, middleStart, middleStart);
+        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 {
+
+    String[] stringArray;
+
     public WordCounter(String... strings) {
+        this.stringArray = strings;
     }
 
     public Map<String, Integer> getWordCountMap() {
-        return null;
+
+        Map<String, Integer> map = new HashMap<>();
+        for (String s : stringArray) {
+            map.compute(s, (k, v) -> (v == null) ? 1 : v+1);
+        }
+        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,34 @@
 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 {
+
+    private List<Spice> spices;
+
+    public Food() {
+        this.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> map = new HashMap<>();
+        for (Spice s : spices) {
+            map.compute((SpiceType) s.getClass(), (k, v) -> (v == null) ? 1 : v + 1);
+        }
+        return map;
     }
 
     public void applySpice(Spice spice) {
+        this.spices.add(spice);
     }
 }

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

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

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

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

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

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

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

@@ -1,35 +1,37 @@
 package rocks.zipcode.quiz4.fundamentals;
 
+import java.util.Arrays;
+
 /**
  * @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;
+        return Arrays.asList(value).stream().map(v -> squareRoot(v)).toArray(Double[]::new);
     }
 
     public static Double[] squares(Double... values) {
-        return null;
+        return Arrays.asList(values).stream().map(v -> square(v)).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,75 @@
 package rocks.zipcode.quiz4.fundamentals;
 
+import java.util.*;
+
+
 /**
  * @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;
+        StringBuffer result = new StringBuffer(str);
+        for (int i = 0; i < str.length(); i++) {
+            int mid = str.length() / 2;
+            result.setCharAt(mid, Character.toUpperCase(str.charAt(mid)));
+        }
+        return result.toString();
     }
 
     public static String lowerCaseMiddleCharacter(String str) {
-        return null;
+        StringBuffer result = new StringBuffer(str);
+        for (int i = 0; i < str.length(); i++) {
+            int mid = str.length() / 2;
+            result.setCharAt(mid, Character.toLowerCase(str.charAt(mid)));
+        }
+        return result.toString();
     }
 
     public static Boolean isIsogram(String str) {
-        return null;
+        int length = str.length();
+        char[] arr = str.toCharArray();
+        Arrays.sort(arr);
+        for (int i = 0; i < length - 1; i++) {
+            if (arr[i] == arr[i + 1]) return false;
+        }
+        return true;
     }
 
     public static Boolean hasDuplicateConsecutiveCharacters(String str) {
-        return null;
+        return (str.matches(".*(.)\\1.*"));
     }
 
+
     public static String removeConsecutiveDuplicateCharacters(String str) {
-        return null;
+        ArrayList<Character> dups = new ArrayList<>();
+        String result = "";
+        for (int i = 0; i < str.length()-1; i++) {
+            if(str.charAt(i) == str.charAt(i+1)) dups.add(str.charAt(i));
+        }
+        for (int i = 0; i < str.length()-1; i++) {
+            if(!dups.contains(str.charAt(i))) result += str.charAt(i);
+        }
+        result += str.charAt(str.length()-1);
+        return result;
     }
 
+
     public static String invertCasing(String str) {
-        return null;
+        char[] array = str.toCharArray();
+
+        for (int i = 0; i < array.length; i++) {
+            char c = array[i];
+            if (Character.isUpperCase(c)) {
+                array[i] = Character.toLowerCase(c);
+            }
+            else if (Character.isLowerCase(c)) {
+                array[i] = Character.toUpperCase(c);
+            }
+        }
+        return new String(array);
     }
 }

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 this.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,27 @@
 package rocks.zipcode.quiz4.objectorientation.account;
 
+import java.util.ArrayList;
+
 /**
  * @author leon on 27/12/2018.
  */
 public class Bank {
+
+    private ArrayList<BankAccount> bankAccounts;
+
+    public Bank() {
+        this.bankAccounts = new ArrayList<>();
+    }
+
     public BankAccount removeBankAccountByIndex(Integer indexNumber) {
-        return null;
+        return bankAccounts.remove((int)indexNumber);
     }
 
     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/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() { balance = 0.0; }
+
+    public void setBalance(Double val) { this.balance = val;
+    }
+
+    @Override
+    public void deposit(Double amountToIncreaseBy) {
+        if (amountToIncreaseBy < 0.0){
+            throw new IllegalArgumentException("Cannot deposit negative number!");
+        } else {
+            balance += amountToIncreaseBy;
+        }
+
+    }
+
+    @Override
+    public void withdrawal(Double amountToDecreaseBy) {
+        if (amountToDecreaseBy > 0 && this.balance >= amountToDecreaseBy) {
+            this.balance -= amountToDecreaseBy;
+        } else {
+            throw new IllegalArgumentException("Cannot process transaction");
+        }
+    }
+
+    @Override
+    public Double getBalance() {
+        return this.balance;
     }
 }