Unable to finish OOP.

src/main/java/com/dtcc/exams/arrays/IntegerArrayUtils.java

@@ -7,7 +7,15 @@ public class IntegerArrayUtils {
      * @return - identical array with one additional element of `valueToBeAdded` at the end of the array
      */
     public static Integer[] add(Integer[] integerArray, Integer valueToBeAdded) {
-        return null;
+
+        Integer[] temp = new Integer[integerArray.length+1];
+        //Copy original contents
+        for(int i =0; i < integerArray.length; i++){
+            temp[i] = integerArray[i];
+        }
+        //Add new
+        temp[integerArray.length] = valueToBeAdded;
+        return temp;
     }
 
     /**
@@ -17,7 +25,8 @@ public static Integer[] add(Integer[] integerArray, Integer valueToBeAdded) {
      * @return `integerArray` with `valueToBeInserted` at index number `indexToInsertAt`
      */
     public static Integer[] replace(Integer[] integerArray, int indexToInsertAt, Integer valueToBeInserted) {
-        return null;
+        integerArray[indexToInsertAt] = valueToBeInserted;
+        return integerArray;
     }
 
     /**
@@ -26,30 +35,54 @@ public static Integer[] replace(Integer[] integerArray, int indexToInsertAt, Int
      * @return element located at `indexToFetch`
      */
     public static Integer get(Integer[] integerArray, Integer indexToFetch) {
-        return null;
+        return integerArray[indexToFetch];
     }
 
     /**
      * @param integerArray - array to be evaluated
      * @return identical array with even-values incremented by 1 and odd-values decremented by 1
      */
     public static Integer[] incrementEvenDecrementOdd(Integer[] integerArray) {
-        return null;
+        Integer[] temp = new Integer[integerArray.length];
+        for(int i = 0; i < integerArray.length; i++){
+            if(integerArray[i] % 2 == 0){
+                temp[i] = (integerArray[i] + 1);
+            }else{
+                temp[i] = (integerArray[i] - 1);
+            }
+        }
+        return temp;
     }
 
     /**
      * @param integerArray - array to be evaluated
      * @return identical array with even-values incremented by 1
      */
     public static Integer[] incrementEven(Integer[] integerArray) {
-        return null;
+        Integer[] temp = new Integer[integerArray.length];
+        for(int i = 0; i < integerArray.length; i++){
+            if(integerArray[i] % 2 == 0){
+                temp[i] = (integerArray[i] + 1);
+            }else{
+                temp[i] = integerArray[i];
+            }
+        }
+        return temp;
     }
 
     /**
      * @param input - array to be evaluated
      * @return identical array with odd-values decremented by 1
      */
     public static Integer[] decrementOdd(Integer[] input) {
-        return null;
+        Integer[] temp = new Integer[input.length];
+        for(int i = 0; i < input.length; i++){
+            if(input[i] % 2 == 0){
+                temp[i] = (input[i]);
+            }else{
+                temp[i] = (input[i] -1);
+            }
+        }
+        return temp;
     }
 }

src/main/java/com/dtcc/exams/arrays/StringArrayUtils.java

@@ -1,5 +1,7 @@
 package com.dtcc.exams.arrays;
 
+import java.util.Arrays;
+
 public class StringArrayUtils {
     /**
      * @param arrayToBeSpliced - array to be evaluated
@@ -8,7 +10,7 @@ public class StringArrayUtils {
      * @return an array with all elements between `startingIndex` and `endingIndex`
      */
     public static String[] getSubArray(String[] arrayToBeSpliced, int startingIndex, int endingIndex) {
-        return null;
+        return Arrays.copyOfRange(arrayToBeSpliced,startingIndex,endingIndex);
     }
 
 
@@ -18,6 +20,6 @@ public static String[] getSubArray(String[] arrayToBeSpliced, int startingIndex,
      * @return an array all elements between after `startingIndex`
      */
     public static String[] getEndingArray(String[] arrayToBeSpliced, int startingIndex) {
-        return null;
+        return Arrays.copyOfRange(arrayToBeSpliced, startingIndex, arrayToBeSpliced.length);
     }
 }

src/main/java/com/dtcc/exams/atm/Account.java

@@ -1,25 +1,49 @@
 package com.dtcc.exams.atm;
 
 public class Account {
-
+
+    double balance;
+    boolean accountClosed;
+
+    public Account(){
+        this(0.0);
+    }
+
     public Account(double v) {
+        this.balance = v;
+        if(v != 0.0){
+            this.accountClosed = false;
+        }else{
+            this.accountClosed = true;
+        }
     }
 
     public double balance() {
-        return 0.0;
+        return balance;
     }
 
     public boolean closeAccount() {
-        return false;
+        if(this.balance() == 0){
+            this.accountClosed = true;
+        }
+        return this.accountClosed;
     }
 
     public void deposit(double v) {
+        this.balance += v;
     }
 
     public Double withdraw(double v) {
-        return 0.0;
+        if(this.balance >= v) {
+            this.balance -= v;
+        }
+        return this.balance;
     }
 
     public void transfer(Account b, double v) {
+        if(this.balance() >= v){
+            this.withdraw(v);
+            b.deposit(v);
+        }
     }
 }

src/main/java/com/dtcc/exams/collections/Inventory.java

@@ -1,6 +1,9 @@
 package com.dtcc.exams.collections;
 
+
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Use a map to keep track of inventory in a store
@@ -9,36 +12,47 @@ public class Inventory {
     /**
      * @param strings list of strings to add / remove / fetch from
      */
-    public Inventory(List<String> strings) {
-
-    }
+    public Map<String, Integer> inventory;
 
     /**
      * nullary constructor initializes a new list
      */
     public Inventory() {
+        inventory = new HashMap<>();
+    }
 
+    public Inventory(List<String> strings) {
+        inventory = new HashMap<>();
+        for(String item:strings){
+            if(inventory.containsKey(item)){
+                inventory.put(item,inventory.get(item) +1);
+            }else{
+                inventory.put(item, 1);
+            }
+        }
     }
 
+
+
     /**
      * @param item - increment the number of this item in stock by 1
      */
     public void addItemToInventory(String item) {
-        return;
+        inventory.put(item, getItemQuantity(item) + 1);
     }
 
     /**
      * @param item - decrement the number of this item in stock by 1
      */
     public void removeItemFromInventory(String item) {
-        return;
+        inventory.put(item, getItemQuantity(item)-1);
     }
 
     /**
      * @param item - Search for this item in stock
      * @return - return the number of items
      */
     public Integer getItemQuantity(String item) {
-        return null;
+           return inventory.getOrDefault(item, 0);
     }
 }

src/main/java/com/dtcc/exams/collections/MonthConversion.java

@@ -1,61 +1,85 @@
 package com.dtcc.exams.collections;
 
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
 /**
  * Use a map to solve
  */
 public class MonthConversion {
+
+    public Map<Integer, String> conversion = new HashMap<>();
     /**
      * @param monthNumber - ordinal of month in the year; i.e. January = 1, February = 2
      * @param monthName - name of month
      */
     public void add(Integer monthNumber, String monthName) {
-
+        conversion.put(monthNumber, monthName);
     }
 
     /**
      * @param monthNumber - ordinal of month in the year
      * @return the name of the respective month
      */
     public String getName(Integer monthNumber) {
-        throw new NullPointerException();
+        return conversion.get(monthNumber);
     }
 
     /**
      * @param monthName - name of month
      * @return - the ordinal of the month in the year
      */
-    public int getNumber(String monthName) {
-        return (Integer)null;
+    public Integer getNumber(String monthName) {
+        Integer monthNumber = 0;
+        for(Map.Entry m: conversion.entrySet()){
+           if((m.getValue().equals(monthName))){
+               monthNumber = (Integer)m.getKey();
+               return monthNumber;
+           }
+        }
+        return null;
     }
 
     /**
      * @param monthNumber
      * @return true if the monthNumber is in the keySet
      */
     public Boolean isValidNumber(Integer monthNumber) {
-        return null;
+        return conversion.containsKey(monthNumber);
     }
 
     /**
      * @param monthName
      * @return true if the monthName is in the valueSet
      */
     public Boolean isValidMonth(String monthName) {
-        return null;
+       boolean temp = false;
+        for(Map.Entry m: conversion.entrySet()){
+            if((m.getValue().equals(monthName))){
+               return true;
+            }
+        }
+        return temp;
     }
 
     /**
      * @return number of entries in this mapping
      */
     public Integer size() {
-        return -1;
+        return conversion.size();
     }
 
     /**
      * @param monthNumber - number of month in year
      * @param monthName - name of month
      */
     public void update(Integer monthNumber, String monthName) {
-
+        if(conversion.containsKey(monthNumber)){
+            conversion.replace(monthNumber, monthName);
+        }else{
+            conversion.put(monthNumber,monthName);
+        }
     }
 }

src/main/java/com/dtcc/exams/fundamentals/BasicStringUtils.java

@@ -6,16 +6,18 @@ public class BasicStringUtils {
      * @param string2 - String to add to `string1`
      * @return concatenation of `string1` and `string2`
      */
-    public static String concatentate(String string1, String string2) {
-        return null;
-    }
+    public static String concatentate(String string1, String string2) {return string1+string2;}
 
     /**
      * @param string1 - String to be reversed
      * @return an identical string with characters in reverse order
      */
     public static String reverse(String string1) {
-        return null;
+        String temp = "";
+        for(int i = string1.length()-1; i >= 0; i--){
+            temp += string1.charAt(i) + "";
+        }
+        return temp;
     }
 
     /**
@@ -24,7 +26,7 @@ public static String reverse(String string1) {
      * @return concatenation of the reverse of `string1` and reverse of `string2`
      */
     public static String reverseThenConcatenate(String string1, String string2) {
-        return null;
+        return reverse(string1) + reverse(string2);
     }
 
     /**
@@ -33,7 +35,8 @@ public static String reverseThenConcatenate(String string1, String string2) {
      * @return `string` with `charactersToRemove` removed
      */
     public static String removeCharacters(String string, String charactersToRemove) {
-        return null;
+        String temp = string.replaceAll("[" + charactersToRemove +"]", "");
+        return temp;
     }
 
     /**
@@ -42,6 +45,6 @@ public static String removeCharacters(String string, String charactersToRemove)
      * @return reverse of `string` with `charactersToRemove` removed
      */
     public static String removeCharactersThenReverse(String string, String charactersToRemove) {
-        return null;
+        return reverse(removeCharacters(string, charactersToRemove));
     }
 }