String Array Utilities CRUSHED

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

 package com.zipcodewilmington;
 
+import com.sun.tools.javac.util.ArrayUtils;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
 /**
  * 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;
+            int x = array.length;
+        return array[x-1];
     }
 
     /**
      * @return second to last element in specified array
      */ // TODO
     public static String getSecondToLastElement(String[] array) {
-        return null;
+        int x = array.length;
+        return array[x-2];
+
     }
 
     /**
      * @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 (value == array[i]){
+                return true;
+            }
+        }
         return false;
     }
 
      * @return an array with identical contents in reverse order
      */ // TODO
     public static String[] reverse(String[] array) {
-        return null;
+//        List<String> list = Arrays.asList(array);
+//        Collections.reverse(list);
+//        return list.toArray(new String[list.size()]);
+
+        String[] newArray = new String[array.length];
+
+        for(int i = 0; i < array.length; i++) {
+            newArray[i] = array[array.length - i - 1];
+        }
+
+        return newArray;
+
     }
 
     /**
      * @return true if the order of the array is the same backwards and forwards
      */ // TODO
     public static boolean isPalindromic(String[] array) {
-        return false;
+        boolean truth = true;
+
+
+        for(int i = 0; i < array.length; i++) {
+            if (array[i] != array[array.length - i - 1]) {
+                truth = false;
+            }
+        }
+        return truth;
     }
 
     /**
      * @return true if each letter in the alphabet has been used in the array
      */ // TODO
     public static boolean isPangramic(String[] array) {
-        return false;
+        char[] alphabet = new char[26];
+        boolean[] alphabet2 = new boolean[26];
+        alphabet[0] = 'a';
+        alphabet2[0] = false;
+        boolean isPan = true;
+
+
+        for (int i = 1; i < alphabet.length; i++){
+            alphabet[i] += 'a' + i;
+            alphabet2[i] = false;
+            // System.out.println("alphabet of " + i + "equals " + alphabet[i]);
+            // System.out.println("alphabet of " + i + "equals " + alphabet2[i]);
+        }
+
+        for (int i = 0; i < array.length; i++){
+            array[i] = array[i].toLowerCase();
+            for(int j = 0; j < array[i].length(); j++) {
+                for (int k = 0; k < 26; k++) {
+                    if (array[i].charAt(j) == alphabet[k])
+                        alphabet2[k] = true;
+                }
+                // System.out.println(alphabet[i]+ " of " + i + "is " + alphabet2[i]);
+            }
+        }
+
+        for(int z = 0; z < alphabet2.length; z++){
+            if (alphabet2[z] == false){
+                isPan = false;
+            }
+        }
+
+        // String[] words = {"ab", "bb", "cb", "db"};
+        //  char newWord = words[0].charAt(1);
+
+        return isPan;
     }
 
     /**
      * @return number of occurrences the specified `value` has occurred
      */ // TODO
     public static int getNumberOfOccurrences(String[] array, String value) {
-        return 0;
+        int numOccur = 0;
+        for (int i = 0; i < array.length; i++){
+            if (array[i].equals(value)){
+                numOccur += 1;
+            }
+        }
+
+        return numOccur;
     }
 
     /**
      * @return array with identical contents excluding values of `value`
      */ // TODO
     public static String[] removeValue(String[] array, String valueToRemove) {
-        return null;
+        StringBuilder builder = new StringBuilder();
+//        builder.append(array[0] + " ");
+
+        for (int i = 0; i < array.length; i++){
+            if (!array[i].equals(valueToRemove)){
+                builder.append(array[i]+" ");
+            }
+//            System.out.println(builder);
+        }
+
+        return builder.toString().split(" ");
+
+
     }
 
     /**
      * @return array of Strings with consecutive duplicates removes
      */ // TODO
     public static String[] removeConsecutiveDuplicates(String[] array) {
-        return null;
+        StringBuilder builder = new StringBuilder();
+        builder.append(array[0] + " ");
+
+
+        for (int i = 1; i < array.length; i++){
+            if (array[i] != array[i-1]){
+                builder.append(array[i]+" ");
+            }
+//            System.out.println(builder);
+        }
+
+        return builder.toString().split(" ");
     }
 
     /**
      * @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;
-    }
+        StringBuilder builder = new StringBuilder();
 
+        builder.append(array[0]);
+
+        for (int i = 1; i < array.length; i++){
+            if (array[i] != array[i-1]){
+                builder.append("," + array[i]);
+            } else {
+                builder.append(array[i]);
+            }
+        }
+
+        return builder.toString().split(",");
+    }
 
 }