completed

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

 package com.zipcodewilmington;
 
 
+import java.lang.reflect.Array;
 import java.util.Arrays;
 
 /**
      * @return true if the array contains the specified `value`
      */ // TODO
     public static boolean contains(String[] array, String value) {
-        for(String counter : array) {
-            if(counter.equals(value)) {
+        for (String counter : array) {
+            if (counter.equals(value)) {
                 return true;
             }
         }
     public static String[] reverse(String[] array) {
         String[] reverseArray = new String[array.length];
         int b = 1;
-        for(int j = 0; j < reverseArray.length; j++){
+        for (int j = 0; j < reverseArray.length; j++) {
             reverseArray[j] = array[array.length - b];
             b++;
-            }
+        }
 
 
-            return reverseArray;
+        return reverseArray;
     }
 
     /**
      * @return true if the order of the array is the same backwards and forwards
      */ // TODO
     public static boolean isPalindromic(String[] array) {
-        String[] reverseArray = new String[array.length];
-        int b = 1;
-        for(int j = 0; j < reverseArray.length; j++){
-            reverseArray[j] = array[array.length - b];
-            b++;
-        }
+        String[] testArray = reverse(Arrays.copyOf(array, array.length));
 
-        return reverseArray == array ? false: true;
+        return Arrays.equals(array, testArray);
     }
 
     /**
      * @return true if each letter in the alphabet has been used in the array
      */ // TODO
     public static boolean isPangramic(String[] array) {
-            String alphaString = array.toString().toLowerCase();
-            for(char l = 'a'; l <= 'z'; l++) {
-                if (!alphaString.contains(String.valueOf(l))) {
-                    return false;
-                }
+        String alphaString = Arrays.toString(array).toLowerCase();
+        for (char l = 'a'; l <= 'z'; l++) {
+            if (!alphaString.contains(String.valueOf(l))) {
+                return false;
             }
-              return true;
+        }
+        return true;
     }
 
     /**
      */ // TODO
     public static int getNumberOfOccurrences(String[] array, String value) {
         int counter = 0;
-        for(String looper : array) {
+        for (String looper : array) {
             if (looper.equals(value)) {
                 counter++;
             }
      * @param valueToRemove value to remove from array
      * @return array with identical contents excluding values of `value`
      */ // TODO
-
-        public static String[] removeValue(String[] array, String valueToRemove) {
-            String[] tempArray = new String[array.length];
-            int newIdx = 0;
-            for(int i = 0; i < array.length; i++){
-                if(array[i] != valueToRemove) {
-                    tempArray[newIdx] = array[i];
-                    newIdx++;
-                }
-
+    public static String[] removeValue(String[] array, String valueToRemove) {
+        String[] tempArray = new String[array.length];
+        int newIdx = 0;
+        for (int i = 0; i < array.length; i++) {
+            if (array[i] != valueToRemove) {
+                tempArray[newIdx] = array[i];
+                newIdx++;
             }
-            return Arrays.copyOf(tempArray, newIdx);
 
         }
+        return Arrays.copyOf(tempArray, newIdx);
+
+    }
 
     /**
      * @param array array of chars
         String[] tempArray = new String[array.length];
         int newIdx = 0;
 
-        for(int i = 1; i < array.length; i++){
+        for (int i = 1; i < array.length; i++) {
             String current = array[i - 1];
-            if(!current.equals(array[i])){
+            if (!current.equals(array[i])) {
                 tempArray[newIdx] = array[i - 1];
-              newIdx++;
+                newIdx++;
             }
         }
         tempArray[newIdx] = array[array.length - 1];
     }
 
 
-
     /**
      * @param array array of chars
      * @return array of Strings with each consecutive duplicate occurrence concatenated as a single string in an array of Strings
     public static String[] packConsecutiveDuplicates(String[] array) {
         String[] tempArray = new String[array.length];
         int newIdx = 0;
+        String last = array[0];
+        String combiner = array[0];
+
+        for (int i = 1; i < array.length; i++) {
+            if (!last.equals(array[i])) {
+                last = array[i];
+                tempArray[newIdx] = combiner;
+                combiner = array[i];
+                newIdx++;
+            } else {
+                combiner += array[i];
+
+            }
+
+        }
+        tempArray[newIdx] = combiner;
+        //tempArray[newIdx] = array[array.length - 1];
+        return Arrays.copyOf(tempArray, newIdx + 1);
+
+
+
+
+
+
+
+
+
+
+
+
+        /*String[] tempArray = new String[array.length];
+        int newIdx = 0;
         String last  = array[0];
         String next = "";
         String set = "";
              next = array[i+1];
             if(next.equals(last)){
                 set += last;
+                last = array[i+1];
 
             } else {
                 tempArray[newIdx] = set;
                 set ="";
                 newIdx++;
-            }
-
-        }
-
-         return Arrays.copyOf(tempArray, newIdx + 1);
-        
+            }*/
+        //return Arrays.copyOf(tempArray, newIdx + 1);
     }
 
+
 }
 
 
+
+