quiz 4

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

@@ -1,22 +1,37 @@
 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 result = values.length / 2;
+        return values[result];
+
     }
 
     public static String[] removeMiddleElement(String[] values) {
-        return null;
+        String[] result = new String[values.length - 1];
+        int middle = values.length / 2;
+        int index = 0;
+        for (int i = 0; i < values.length; i++) {
+            if (i != middle) {
+                result[index] = values[i];
+                index++;
+
+            }
+
+        }
+        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,25 @@
 package rocks.zipcode.quiz4.collections;
 
+import java.util.HashMap;
 import java.util.Map;
 
 public class WordCounter {
+    String [] strings;
+
     public WordCounter(String... strings) {
+        this.strings = strings;
     }
 
     public Map<String, Integer> getWordCountMap() {
-        return null;
+        Map<String, Integer> wordCountMap = new HashMap<>();
+        for (String word : strings) {
+            if(wordCountMap.putIfAbsent(word, 1) != null) {
+                Integer count = wordCountMap.get(word) + 1;
+                wordCountMap.replace(word, count);
+            }
+        }
+
+        return wordCountMap;
     }
 }
+

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,40 @@
 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;
+
+    public Food() {
+        this.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> result = new HashMap<>();
+
+        for(Spice spice: spices){
+            Integer counter = 1;
+            if(result.containsKey((SpiceType) spice.getClass())){
+                counter = result.get((SpiceType) spice.getClass());
+                counter++;
+            }
+            result.put((SpiceType) spice.getClass(), counter);
+        }
+
+        return result;
     }
 
     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,6 @@
 /**
  * @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,41 @@
 package rocks.zipcode.quiz4.fundamentals;
 
+import static java.lang.Math.sqrt;
+
 /**
  * @author leon on 21/12/2018.
  */
 public class Calculator {
     public static Double squareRoot(Double value) {
-        return null;
+        return sqrt(value);
     }
 
     public static Double square(Double value) {
-        return null;
+        return value * value;
     }
 
     public static Double[] squareRoots(Double... value) {
-        return null;
+        for(int i = 0; i < value.length; i++)
+            value[i] = squareRoot(value[i]);
+        return value;
     }
 
+
     public static Double[] squares(Double... values) {
-        return null;
+        for(int i = 0; i < values.length; i++)
+            values[i] = square(values[i]);
+        return values;
     }
 
     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,69 @@
 package rocks.zipcode.quiz4.fundamentals;
 
+import java.util.Arrays;
+
 /**
  * @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;
+        return str.substring(0, str.length() / 2) + getMiddleCharacter(str.toUpperCase()) + str.substring(( str.length() / 2 ) + 1);
     }
 
     public static String lowerCaseMiddleCharacter(String str) {
-        return null;
+        return str.substring(0, str.length() / 2) + getMiddleCharacter(str.toLowerCase()) + str.substring(( str.length() / 2 ) + 1);
     }
 
     public static Boolean isIsogram(String str) {
-        return null;
-    }
+        int len = str.length();
+
+        char[] arr = str.toCharArray();
+
+        Arrays.sort(arr);
+        for (int i = 0; i < len; i++) {
+            for (int j = i + 1; j < len; j++) {
+                if (arr[i] == arr[j])
+                    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;
+
+        for (int i = 0; i < str.length() - 1; i++) {
+            if (str.charAt(i) == str.charAt(i + 1)) {
+                str = str.substring(0, i) + str.substring(i + 2);
+            }
+        }
+        return str;
     }
 
     public static String invertCasing(String str) {
-        return null;
+        StringBuilder builder = new StringBuilder();
+        for (Character chr : str.toCharArray()){
+            if (Character.isUpperCase(chr)){
+                builder.append(Character.toLowerCase(chr));
+            } else {
+                builder.append(Character.toUpperCase(chr));
+            }
+        }
+        return builder.toString();
     }
-}
+}

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

@@ -3,11 +3,16 @@
 /**
  * @author leon on 30/12/2018.
  */
-public class Account extends BankAccount {
+public class Account{
+
+    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,30 @@
 package rocks.zipcode.quiz4.objectorientation.account;
 
+import java.util.ArrayList;
+
 /**
  * @author leon on 27/12/2018.
  */
 public class Bank {
+
+    public ArrayList<BankAccount> Accounts = new ArrayList<>();
+
     public BankAccount removeBankAccountByIndex(Integer indexNumber) {
-        return null;
+        int index = indexNumber;
+        BankAccount bankAccount = Accounts.get(indexNumber);
+        Accounts.remove(index);
+        return bankAccount;
     }
 
+
     public void addBankAccount(BankAccount bankAccount) {
+        Accounts.add(bankAccount);
     }
 
     public Boolean containsBankAccount(BankAccount bankAccount) {
-        throw new UnsupportedOperationException("Method not yet implemented");
+        if(Accounts.contains(bankAccount)) {
+            return true;
+        }
+        return false;
     }
-}
+}

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

@@ -3,7 +3,42 @@
 /**
  * @author leon on 27/12/2018.
  */
-public class BankAccount {
+
+public class BankAccount extends Account implements Transactable {
+
+    public double balance;
+
+    public BankAccount() {
+        this.balance = 0.0;
+    }
+
+    public BankAccount(Double val) {
+        this.balance = val;
+    }
+
     public void setBalance(Double val) {
+        this.balance = val;
+    }
+
+    @Override
+    public void deposit(Double amountToIncreaseBy) {
+        if (amountToIncreaseBy < 0.0) {
+            throw new IllegalArgumentException("error");
+        }
+        this.balance += amountToIncreaseBy;
+    }
+
+    @Override
+    public void withdrawal(Double amountToDecreaseBy) {
+        if ((this.balance - amountToDecreaseBy < 0.0)|| (amountToDecreaseBy < 0.0)) {
+            throw new IllegalArgumentException("Insufficient funds");
+        } else {
+            this.balance -= amountToDecreaseBy;
+        }
+    }
+
+    @Override
+    public Double getBalance() {
+        return balance;
     }
-}
+}