finished lab

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

@@ -1,22 +1,29 @@
 package rocks.zipcode.quiz4.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[values.length / 2];
     }
 
     public static String[] removeMiddleElement(String[] values) {
-        return null;
+        List<String> l = new ArrayList<>(Arrays.asList(Arrays.copyOfRange(values, 0, values.length / 2)));
+        l.addAll(Arrays.asList(Arrays.copyOfRange(values, values.length/2+1, values.length)));
+
+        return l.toArray(new String[l.size()]);
     }
 
     public static String getLastElement(String[] values) {
-        return null;
+        return values[values.length - 1];
     }
 
     public static String[] removeLastElement(String[] values) {
-        return null;
+        return Arrays.copyOfRange(values,0,values.length - 1);
     }
 }

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

@@ -1,12 +1,19 @@
 package rocks.zipcode.quiz4.collections;
 
+import java.util.HashMap;
 import java.util.Map;
 
 public class WordCounter {
+    Map<String, Integer> wordCounterMap = new HashMap<>();
+
     public WordCounter(String... strings) {
+        for (String string : strings){
+            wordCounterMap.putIfAbsent(string, 0);
+            wordCounterMap.replace(string, wordCounterMap.get(string) + 1);
+        }
     }
 
     public Map<String, Integer> getWordCountMap() {
-        return null;
+        return wordCounterMap;
     }
 }

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,29 @@
 package rocks.zipcode.quiz4.collections.culonary;
 
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
 /**
  * @author leon on 27/12/2018.
  */
 public class Food {
+    private Map<Class<? extends Spice>, Integer> spiceCount = new LinkedHashMap<>();
+    private 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;
+    public Map<Class<? extends Spice>, Integer> getSpiceCount() {
+        return spiceCount;
     }
 
     public void applySpice(Spice spice) {
+        spiceCount.putIfAbsent(spice.getClass(), 0);
+        spiceCount.replace(spice.getClass(),spiceCount.get(spice.getClass()) + 1);
+
+        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

@@ -5,31 +5,39 @@
  */
 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;
+        Double[] result = new Double[value.length];
+        for (int i = 0; i < value.length; i++)
+            result[i] = Math.sqrt(value[i]);
+
+        return result;
     }
 
     public static Double[] squares(Double... values) {
-        return null;
+        Double[] result = new Double[values.length];
+        for (int i = 0; i < values.length; i++)
+            result[i] = (values[i] * values[i]);
+
+        return result;
     }
 
     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

@@ -5,30 +5,57 @@
  */
 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;
+        return str.substring(0, str.length() / 2) + Character.toUpperCase(getMiddleCharacter(str)) + str.substring(str.length() / 2 + 1);
     }
 
     public static String lowerCaseMiddleCharacter(String str) {
-        return null;
+        return str.substring(0, str.length() / 2) + Character.toLowerCase(getMiddleCharacter(str)) + str.substring(str.length() / 2 + 1);
     }
 
     public static Boolean isIsogram(String str) {
-        return null;
+        for (char c : str.toCharArray())
+            if (!(str.chars().filter(ch -> ch == c).count() == 1))
+                return false;
+
+            return true;
     }
 
     public static Boolean hasDuplicateConsecutiveCharacters(String str) {
-        return null;
+        for (int i = 0; i < str.length() - 1; i++)
+            if (str.charAt(i) == str.charAt(i + 1))
+                return true;
+
+        return false;
     }
 
     public static String removeConsecutiveDuplicateCharacters(String str) {
-        return null;
+        StringBuilder result = new StringBuilder();
+
+        for (int i = 0; i < str.length()-1; i++)
+            if (str.charAt(i)==str.charAt(i+1))
+                i++;
+            else
+                result.append(str.charAt(i));
+
+        result.append(str.charAt(str.length()-1));
+
+        return result.toString();
     }
 
     public static String invertCasing(String str) {
-        return null;
+        StringBuilder result = new StringBuilder();
+        for (char c : str.toCharArray())
+            if (Character.isLowerCase(c))
+                result.append(Character.toUpperCase(c));
+            else if (Character.isUpperCase(c))
+                result.append(Character.toLowerCase(c));
+            else
+                result.append(c);
+
+        return result.toString();
     }
 }

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

@@ -4,10 +4,13 @@
  * @author leon on 30/12/2018.
  */
 public class Account extends BankAccount {
+    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,24 @@
 package rocks.zipcode.quiz4.objectorientation.account;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * @author leon on 27/12/2018.
  */
 public class Bank {
+
+    private List<BankAccount> accounts = new ArrayList<>();
+
     public BankAccount removeBankAccountByIndex(Integer indexNumber) {
-        return null;
+        return accounts.remove(indexNumber.intValue());
     }
 
     public void addBankAccount(BankAccount bankAccount) {
+        accounts.add(bankAccount);
     }
 
     public Boolean containsBankAccount(BankAccount bankAccount) {
-        throw new UnsupportedOperationException("Method not yet implemented");
+        return accounts.contains(bankAccount);
     }
 }

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

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

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

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

src/test/java/rocks/zipcode/quiz4/objectorientation/account/AccountPolymorphismTest.java

@@ -10,11 +10,11 @@ public class AccountPolymorphismTest {
     private Object account = new Account();
     @Test
     public void test1() {
-        Assert.assertFalse(account instanceof Transactable);
+        Assert.assertTrue(account instanceof Transactable);
     }
 
     @Test
     public void test2() {
-        Assert.assertFalse(account instanceof BankAccount);
+        Assert.assertTrue(account instanceof BankAccount);
     }
 }

src/test/java/rocks/zipcode/quiz4/objectorientation/bankaccount/BankAccountPolymorphismTest.java

@@ -19,6 +19,6 @@ public void test1() {
 
     @Test
     public void test2() {
-        Assert.assertTrue(bankAccount instanceof Account);
+        Assert.assertFalse(bankAccount instanceof Account);
     }
 }