final lab

StringArrayUtils.java

- 
-
+import java.util.Arrays;
 /**
  * Created by leon on 1/29/18.
  */
      * @return first element of specified array
      */ // TODO
     public static String getFirstElement(String[] array) {
-        return null;
+        return array[0];
     }
 
     /**
      * @return second element in specified array
      */
     public static String getSecondElement(String[] array) {
-        return null;
+        return array[1];
     }
 
     /**
      * @return last element in specified array
      */ // TODO
     public static String getLastElement(String[] array) {
-        return null;
+        return array[array.length-1];
     }
 
     /**
      * @return second to last element in specified array
      */ // TODO
     public static String getSecondToLastElement(String[] array) {
-        return null;
+        return array[array.length-2];
     }
 
     /**
      * @return true if the array contains the specified `value`
      */ // TODO
     public static boolean contains(String[] array, String value) {
+        for(String answer : array){
+            if(answer.equals(value)){
+                return true;
+            }
+        }
         return false;
     }
 
      * @return an array with identical contents in reverse order
      */ // TODO
     public static String[] reverse(String[] array) {
-        return null;
+        String[] output = new String[array.length];
+        int counter = 0;
+        for (int i = array.length -1; i >= 0; i--) {
+            output[counter] = array[i];
+            counter++;
+        }
+        return output;
     }
 
     /**
      * @return true if the order of the array is the same backwards and forwards
      */ // TODO
     public static boolean isPalindromic(String[] array) {
-        return false;
+        boolean palindromic = false;
+        for (int i = 0; i <= array.length/2; i++) {
+            if (array[i] == array[array.length -1 -i]) {
+                palindromic = true;
+            }
+        }
+
+        return palindromic;
     }
 
     /**
      * @return true if each letter in the alphabet has been used in the array
      */ // TODO
     public static boolean isPangramic(String[] array) {
-        return false;
+        String[] alphabet = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k",
+                "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v",
+                "w", "x", "y", "z" };
+
+        boolean pan = true;
+
+        for (String letter : alphabet) {
+            boolean letterFound = false;
+            for (String letter2 : array) {
+                if (letter2.toLowerCase().contains(letter)) {
+                    letterFound = true;
+                }
+            }
+            if (!letterFound) {
+                pan = false;
+            }
+        }
+
+        return pan;
     }
 
     /**
      * @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 occurence : array){
+            if(occurence.equals(value)) counter++;
+        }
+        return counter;
     }
 
     /**
      * @return array with identical contents excluding values of `value`
      */ // TODO
     public static String[] removeValue(String[] array, String valueToRemove) {
-        return null;
+        int occurrences = getNumberOfOccurrences(array, valueToRemove);
+        String[] valueRemoved;
+        if(occurrences == 0){
+            valueRemoved = array;
+        } else {
+            valueRemoved = new String[array.length - occurrences];
+            int removedArr = 0;
+            for (int i = 0; i < array.length; i++) {
+                if (!array[i].equals(valueToRemove)) {
+                    valueRemoved[removedArr] = array[i];
+                    removedArr++;
+                }
+            }
+        }
+        return valueRemoved;
+
     }
 
     /**
      * @return array of Strings with consecutive duplicates removes
      */ // TODO
     public static String[] removeConsecutiveDuplicates(String[] array) {
-        return null;
+        String lastNumber = null;
+        int index = 0;
+        int counter = 0; 
+
+        for (int i = 0; i < array.length - 1; i++) {
+            if (array[i].equals(array[i + 1])) {
+                counter++;
+            }
+        }
+
+        String [] arr1 = new String [array.length - counter];
+
+        for (int i = 0; i < array.length; i++) {
+
+            if (!array[i].equals(lastNumber)){
+                arr1[index] = array[i];
+                lastNumber = array[i];
+                index++;
+            }
+        }
+
+        return arr1;
     }
 
     /**
      * @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;
+        String[] consecDups = new String[array.length];
+        int j=0;
+        int counter = 0;
+        consecDups[0] = array[0];
+        for (int i = 0; i < array.length-1; i++) {
+            if (array[i].compareTo(array[i+1]) == 0) {
+                consecDups[j] = consecDups[j] + array[i+1];
+                counter++;
+            } else {
+                consecDups[j+1] = array[i+1];
+                j++;
+            }
+        }
+        consecDups = Arrays.copyOf(consecDups, array.length-counter);
+        return consecDups;
     }
 
-
 }