completed arrays

src/main/java/com/zipcodewilmington/StringArrayUtils.java

@@ -1,15 +1,21 @@
 package com.zipcodewilmington;
 
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
 /**
  * Created by leon on 1/29/18.
  */
-public class StringArrayUtils {
+public class  StringArrayUtils {
     /**
      * @param array array of String objects
      * @return first element of specified array
      */ // TODO
     public static String getFirstElement(String[] array) {
-        return null;
+        return array[0];
     }
 
     /**
@@ -17,15 +23,16 @@ public class StringArrayUtils {
      * @return second element in specified array
      */
     public static String getSecondElement(String[] array) {
-        return null;
+        return array[1];
     }
 
     /**
      * @param array array of String objects
      * @return last element in specified array
      */ // TODO
-    public static String getLastElement(String[] array) {
-        return null;
+    public static String getLastElement(String[] array)
+    {
+        return array[array.length-1];
     }
 
     /**
@@ -33,7 +40,7 @@ public class StringArrayUtils {
      * @return second to last element in specified array
      */ // TODO
     public static String getSecondToLastElement(String[] array) {
-        return null;
+        return array[array.length-2];
     }
 
     /**
@@ -42,6 +49,11 @@ public class StringArrayUtils {
      * @return true if the array contains the specified `value`
      */ // TODO
     public static boolean contains(String[] array, String value) {
+        for (int i =0; i<array.length;i++){
+            if (array[i].equals(value)){
+                return true;
+            }
+        }
         return false;
     }
 
@@ -50,7 +62,13 @@ public class StringArrayUtils {
      * @return an array with identical contents in reverse order
      */ // TODO
     public static String[] reverse(String[] array) {
-        return null;
+        String[] reverseArray = new String[array.length];
+        int counter = 0;
+        for (int i = array.length-1; i>=0; i--){
+              reverseArray[counter] = array[i];
+                counter++;
+        }
+        return reverseArray;
     }
 
     /**
@@ -58,7 +76,13 @@ public class StringArrayUtils {
      * @return true if the order of the array is the same backwards and forwards
      */ // TODO
     public static boolean isPalindromic(String[] array) {
-        return false;
+        String[] reverseArray = new String[array.length];
+        int counter = 0;
+        for (int i = array.length-1; i>=0; i--){
+            reverseArray[counter] = array[i];
+            counter++;
+        }
+        return Arrays.deepEquals(array,reverseArray);
     }
 
     /**
@@ -66,7 +90,17 @@ public class StringArrayUtils {
      * @return true if each letter in the alphabet has been used in the array
      */ // TODO
     public static boolean isPangramic(String[] array) {
-        return false;
+        StringBuilder sb = new StringBuilder();
+        for (String var:array){
+            sb.append(var);
+        } String str = sb.toString();
+
+        return str.toLowerCase()
+                .replaceAll("[^a-z]", "")
+                .replaceAll("(.)(?=.*\\1)", "")
+                .length() == 26;
+
+
     }
 
     /**
@@ -75,7 +109,13 @@ public class StringArrayUtils {
      * @return number of occurrences the specified `value` has occurred
      */ // TODO
     public static int getNumberOfOccurrences(String[] array, String value) {
-        return 0;
+        int counter = 0;
+        for (String var: array){
+            if (var.equals(value)){
+                counter++;
+            }
+        }
+        return counter;
     }
 
     /**
@@ -84,7 +124,15 @@ public class StringArrayUtils {
      * @return array with identical contents excluding values of `value`
      */ // TODO
     public static String[] removeValue(String[] array, String valueToRemove) {
-        return null;
+        ArrayList<String> valueRemoved = new ArrayList<String>();
+        for (String var: array){
+            if (!var.equals(valueToRemove)){
+                valueRemoved.add(var);
+            }
+        }
+        String[] strArray = new String[valueRemoved.size()];
+        strArray = valueRemoved.toArray(strArray);
+        return strArray;
     }
 
     /**
@@ -92,7 +140,15 @@ public class StringArrayUtils {
      * @return array of Strings with consecutive duplicates removes
      */ // TODO
     public static String[] removeConsecutiveDuplicates(String[] array) {
-        return null;
+        ArrayList<String> rCDA = new ArrayList<String>();
+        rCDA.add(array[0]);
+        for (int i = 1;i<array.length;i++){
+            if (!array[i].equals(array[i-1])){
+                rCDA.add(array[i]);
+            }
+        } String[] strArray = new String[rCDA.size()];
+            strArray = rCDA.toArray(strArray);
+        return strArray;
     }
 
     /**
@@ -100,8 +156,75 @@ public class StringArrayUtils {
      * @return array of Strings with each consecutive duplicate occurrence concatenated as a single string in an array of Strings
      */ // TODO
     public static String[] packConsecutiveDuplicates(String[] array) {
-        return null;
+        Integer startingPoint = 0;
+        ArrayList<String> listToReturn = new ArrayList<String>();
+        HashMap<String, Integer> map = determineNumberOfDuplicateCharactersInARow(array, startingPoint);
+        String character =  getKey(map);
+        Integer integer = getInteger(map);
+        startingPoint = integer;
+        listToReturn.add(buildString(character, integer));
+
+
+
+        System.out.println(listToReturn);
+        String[] strArray = new String[listToReturn.size()];
+        strArray = listToReturn.toArray(strArray);
+        return strArray;
     }
 
+    private static String buildString(String string, Integer integer) {
+        String returnString = "";
+        for (int i = 0; i < integer; i++) {
+            returnString += string;
+        }
+        return returnString;
+    }
+
+    private static String getKey(HashMap<String, Integer> map) {
+        String string = "";
+        for (Map.Entry<String, Integer> entry : map.entrySet()) {
+            string = entry.getKey();
+        }
+        return string;
+    }
+
+    private static Integer getInteger(HashMap<String, Integer> map) {
+        Integer integer = 0;
+        for (Map.Entry<String, Integer> entry : map.entrySet()) {
+            integer = entry.getValue();
+        }
+        return integer;
+    }
+
+    private static HashMap<String, Integer> determineNumberOfDuplicateCharactersInARow(String[] arrayToFindConsecutiveDuplicatesIn, Integer startingPoint) {
+        HashMap<String, Integer> map = new HashMap<String, Integer>();
+        ArrayList<String> arrayList = createArrayList(arrayToFindConsecutiveDuplicatesIn);
+        String currentCharacter = arrayList.get(startingPoint);
+        //System.out.println("current character = " + currentCharacter);
+        int numberOfDuplicates = 1;
+        for (int i = startingPoint; i < arrayList.size(); i ++) {
+            String nextCharacter = null;
+            try {
+                nextCharacter = arrayList.get(i + 1);
+            } catch (IndexOutOfBoundsException e) {
+                map.put(currentCharacter, numberOfDuplicates);
+            }
+            //System.out.println("Comparing " + currentCharacter + " to " + nextCharacter);
+            if (!currentCharacter.equals(nextCharacter)) {
+                map.put(currentCharacter, numberOfDuplicates);
+                return map;
+            }
+            //System.out.println("Increasing duplicates");
+            numberOfDuplicates++;
+        }
+        return  map;
+    }
 
+    private static ArrayList<String> createArrayList(String[] array) {
+        ArrayList<String> arrayListToFindConsecutiveDuplicatesIn = new ArrayList<String>();
+        for (int i = 0; i < array.length; i++) {
+            arrayListToFindConsecutiveDuplicatesIn.add(array[i]);
+        }
+        return arrayListToFindConsecutiveDuplicatesIn;
+    }
 }