pom.xml

@@ -26,6 +26,13 @@
             <version>4.12</version>
             <scope>test</scope>
         </dependency>
+        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>3.0</version>
+        </dependency>
+
     </dependencies>
 
 

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

@@ -1,22 +1,31 @@
 package rocks.zipcode.quiz5.arrays;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
 /**
  * @author leon on 01/01/2019.
  */
 public class ArrayUtils {
     public static String getMiddleElement(String[] values) {
-        return null;
+
+        return values[Math.round((values.length - 1) / 2)];
     }
 
     public static String[] removeMiddleElement(String[] values) {
-        return null;
+        List<String> vals = new ArrayList<>(Arrays.asList(values));
+        vals.remove(Math.round((values.length - 1) / 2));
+        return vals.toArray(new String[0]);
     }
 
     public static String getLastElement(String[] values) {
-        return null;
+        return values[values.length-1];
     }
 
     public static String[] removeLastElement(String[] values) {
-        return null;
+        List<String> vals = new ArrayList<>(Arrays.asList(values));
+        vals.remove(Math.round(values.length - 1));
+        return vals.toArray(new String[0]);
     }
 }

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

@@ -2,18 +2,31 @@ package rocks.zipcode.quiz5.collections;
 
 import rocks.zipcode.quiz5.objectorientation.account.BankAccount;
 
+import java.util.ArrayList;
+import java.util.Iterator;
+
 /**
  * @author leon on 27/12/2018.
  */
-public class Bank {
+public class Bank extends ArrayList<BankAccount> {
     public BankAccount removeBankAccountByIndex(Integer indexNumber) {
-        return null;
+        /*Iterator iterator = this.iterator();
+        while(iterator.hasNext()){
+            BankAccount bankAccount = (BankAccount) iterator.next();
+            if()
+        }*/
+
+        BankAccount bankAccount = this.get(indexNumber);
+        this.remove(bankAccount);
+        return bankAccount;
     }
 
     public void addBankAccount(BankAccount bankAccount) {
+        this.add(bankAccount);
     }
 
     public Boolean containsBankAccount(BankAccount bankAccount) {
-        throw new UnsupportedOperationException("Method not yet implemented");
+       // throw new UnsupportedOperationException("Method not yet implemented");
+        return this.contains(bankAccount);
     }
 }

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

@@ -1,7 +1,11 @@
 package rocks.zipcode.quiz5.collections;
 
+import rocks.zipcode.quiz5.objectorientation.Curry;
 import rocks.zipcode.quiz5.objectorientation.Spice;
+import sun.security.provider.ConfigFile;
 
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -9,14 +13,28 @@ 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 spices;
     }
 
     public <SpiceType extends Class<? extends Spice>> Map<SpiceType, Integer> getSpiceCount() {
-        return null;
+        Map<SpiceType, Integer> map = new HashMap<>();
+        for(Spice spice : spices){
+            if(spice instanceof Curry)
+
+            if(!map.containsKey(spice)){
+                map.put(spice, 1);
+            }
+
+            else
+                map.put(spice, map.get(spice) +1);
+        }
+        return map;
     }
 
     public void applySpice(Spice spice) {
+        spices.add(spice);
     }
 }

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

@@ -1,12 +1,23 @@
 package rocks.zipcode.quiz5.collections;
 
-import java.util.Map;
+import java.util.*;
 
 public class WordCounter {
+    List<String> words;
+    Map<String, Integer> wordCount;
     public WordCounter(String... strings) {
+        words = new ArrayList<>(Arrays.asList(strings));
+        wordCount = new HashMap<>();
     }
 
     public Map<String, Integer> getWordCountMap() {
-        return null;
+        for(String word : words)
+        {
+            if(!wordCount.containsKey(word))
+                wordCount.put(word, 1);
+            else
+                wordCount.put(word, wordCount.get(word) + 1);
+        }
+        return wordCount;
     }
 }

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

@@ -1,35 +1,58 @@
 package rocks.zipcode.quiz5.fundamentals;
 
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Matcher;
+
 /**
  * @author leon on 21/12/2018.
  */
 public class Calculator {
+    public static DecimalFormat df2 = new DecimalFormat(".##");
+
     public static Double squareRoot(Double value) {
-        return null;
+        return Double.valueOf(df2.format(Math.sqrt(value)));
     }
 
     public static Double square(Double value) {
-        return null;
+        return Double.valueOf(df2.format(Math.pow(value, 2)));
     }
 
     public static Double[] squareRoots(Double... value) {
-        return null;
+        List<Double> doubles = new ArrayList<>(Arrays.asList(value));
+         Double[] result = new Double[value.length];
+        int index = 0;
+        for(Double val : value){
+            result[index] = Math.sqrt(val);
+            index++;
+        }
+        return result;
     }
 
     public static Double[] squares(Double... values) {
-        return null;
+        Double[] result = new Double[values.length];
+        int index = 0;
+        for(Double val : values){
+            result[index] = Double.valueOf(df2.format(Math.pow(val, 2)));
+            index++;
+        }
+        return result;
     }
 
     public static Double add(Double value1, Double value2) {
-        return null;
+
+        return Double.valueOf(df2.format(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 Double.valueOf(df2.format(divisor/dividend));
     }
 }

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

@@ -1,34 +1,109 @@
 package rocks.zipcode.quiz5.fundamentals;
 
+import com.sun.tools.corba.se.idl.StringGen;
+
+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() - 1) / 2);
     }
 
     public static String capitalizeMiddleCharacter(String str) {
-        return null;
+        Character character = Character.toUpperCase(getMiddleCharacter(str));
+        StringBuilder sb = new StringBuilder(str);
+        int middle = (sb.length() - 1) / 2;
+        sb.deleteCharAt(middle);
+        sb.insert(middle, character);
+        return sb.toString();
     }
 
     public static String lowerCaseMiddleCharacter(String str) {
-        return null;
+        Character character = Character.toLowerCase(getMiddleCharacter(str));
+        StringBuilder sb = new StringBuilder(str);
+        int middle = (sb.length() - 1) / 2;
+        sb.deleteCharAt(middle);
+        sb.insert(middle, character);
+        return sb.toString();
     }
 
     public static Boolean isIsogram(String str) {
-        return null;
+       // str = str.toLowerCase();
+        int len = str.length();
+
+        char arr[] = str.toCharArray();
+
+        Arrays.sort(arr);
+        for (int i = 0; i < len - 1; i++) {
+            if (arr[i] == arr[i + 1])
+                return false;
+        }
+        return true;
     }
 
     public static Boolean hasDuplicateConsecutiveCharacters(String str) {
-        return null;
+       /* for (int i = 0; i < str.length(); i++)
+            for (int j = i + 1; j < str.length(); j++)
+                if (str.charAt(i) == str.charAt(j))
+                    return false;*/
+
+        // If no duplicate characters encountered,
+        // return true
+        str = str.toLowerCase();
+
+        for(int i=1;i<str.length() - 1;i++){
+            if(str.charAt(i-1) == str.charAt(i) || str.charAt(i) == str.charAt(i+1))
+                return true;
+        }
+
+        return false;
     }
 
     public static String removeConsecutiveDuplicateCharacters(String str) {
-        return null;
+//        char prev = '\0';
+//        int k = 0;
+//        char[] chars = str.toCharArray();
+//
+//        for (int i = 0; i < str.length(); i++)
+//        {
+//            if (prev != chars[i]) {
+//                chars[k++] = chars[i];
+//                prev = chars[i];
+//            }
+//        }
+
+  //      return new String(chars).substring(0, k);
+
+
+       /* List<Character> list = new ArrayList<>();
+        int index =0;
+        for(int i=0;i<str.length();i++){
+            if(list.isEmpty() || list.get(index) != str.charAt(i)) {
+                list.add(str.charAt(i));
+                index++;
+            }
+        }
+
+
+        return list.toArray(new Character[0]).toString();*/
+
+       for(int i=0;i<str.length();i++){
+           if(i+1 < str.length() && str.charAt(i) == str.charAt(i+1))
+           {
+
+           }
+       }
+
+
+
+       return null;
     }
 
     public static String invertCasing(String str) {
-        return null;
+
+        return org.apache.commons.lang3.StringUtils.swapCase(str);
     }
 }

src/main/java/rocks/zipcode/quiz5/objectorientation/Curry.java

@@ -1,4 +1,4 @@
 package rocks.zipcode.quiz5.objectorientation;
 
-public class Curry {
+public class Curry implements Spice{
 }

src/main/java/rocks/zipcode/quiz5/objectorientation/Ginger.java

@@ -3,5 +3,5 @@ package rocks.zipcode.quiz5.objectorientation;
 /**
  * @author leon on 27/12/2018.
  */
-public class Ginger {
+public class Ginger implements Spice{
 }

src/main/java/rocks/zipcode/quiz5/objectorientation/Pepper.java

@@ -3,5 +3,5 @@ package rocks.zipcode.quiz5.objectorientation;
 /**
  * @author leon on 27/12/2018.
  */
-public class Pepper {
+public class Pepper implements Spice{
 }

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

@@ -3,7 +3,7 @@ package rocks.zipcode.quiz5.objectorientation.account;
 /**
  * @author leon on 30/12/2018.
  */
-public class Account extends BankAccount {
+public class Account {
     public Long getId() {
         return null;
     }

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

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

src/main/java/rocks/zipcode/quiz5/objectorientation/account/Employee.java

@@ -3,18 +3,63 @@ package rocks.zipcode.quiz5.objectorientation.account;
 /**
  * @author leon on 30/12/2018.
  */
-public class Employee {
+public class Employee implements Worker, Transactable{
+    private BankAccount bankAccount;
+    private Double hoursWorked;
+    private Double hourlyWage;
+    private Double moneyEarned;
+
     public Employee() {
+        this(new BankAccount());
     }
 
     public Employee(BankAccount bankAccount) {
+        this.bankAccount = bankAccount;
+        hoursWorked = 0.0;
+        hourlyWage = 35.0;
+        moneyEarned = 0.0;
     }
 
     public BankAccount getBankAccount() {
-        return null;
+        return this.bankAccount;
     }
 
     public void setBankAccount(BankAccount bankAccount) {
+        this.bankAccount = bankAccount;
+    }
+
+    @Override
+    public void increaseHoursWorked(Double numberOfHours) {
+        this.hoursWorked += numberOfHours;
+    }
+
+    @Override
+    public Double getHoursWorked() {
+        return this.hoursWorked;
+    }
+
+    @Override
+    public Double getHourlyWage() {
+        return this.hourlyWage;
+    }
+
+    @Override
+    public Double getMoneyEarned() {
+        return this.moneyEarned;
+    }
+
+    @Override
+    public void deposit(Double amountToIncreaseBy) {
+        this.bankAccount.deposit(amountToIncreaseBy);
+    }
+
+    @Override
+    public void withdrawal(Double amountToDecreaseBy) {
+        this.bankAccount.withdrawal(amountToDecreaseBy);
+    }
 
+    @Override
+    public Double getBalance() {
+        return this.bankAccount.getBalance();
     }
 }