import java.util.Arrays;

public class StringArrayUtils {
    /**
     * @param array array of String objects
     * @return first element of specified array
     */ // TODO
    public static String getFirstElement(String[] array) {
        return array[0];
    }

    /**
     * @param array array of String objects
     * @return second element in specified array
     */
    public static String getSecondElement(String[] array) {
        return array[1];
    }

    /**
     * @param array array of String objects
     * @return last element in specified array
     */ // TODO
    public static String getLastElement(String[] array) {
        return array[array.length-1];
    }

    /**
     * @param array array of String objects
     * @return second to last element in specified array
     */ // TODO
    public static String getSecondToLastElement(String[] array) {
        return array[array.length-2];
    }

    /**
     * @param array array of String objects
     * @param value value to check array for
     * @return true if the array contains the specified `value`
     */ // TODO
    public static boolean contains(String[] array, String value) {
        boolean answer = false;
        for (String x: array){
            if (x.equals(value))
                answer = true;
        }
        return answer;
    }

    /**
     * @param array of String objects
     * @return an array with identical contents in reverse order
     */ // TODO
    public static String[] reverse(String[] array) {
        String [] str = new String [array.length];
        int count = 0;
        for (int i = array.length-1; i>=0; i--){
            str[count] = array[i];
            count=count+1;
        }
        return str;
    }

    /**
     * @param array array of String objects
     * @return true if the order of the array is the same backwards and forwards
     */ // TODO
    public static boolean isPalindromic(String[] array) {
        String [] newArray = reverse(array);
        if (Arrays.equals(newArray, array)) 
            return true;
        else
            return false;
    }

    /**
     * @param array array of String objects
     * @return true if each letter in the alphabet has been used in the array
     */ // TODO
    public static boolean isPangramic(String[] array) {        

        boolean flag = 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"};

        StringBuilder sb = new StringBuilder();
        for (String element: array)
            sb.append(element);
        String str = sb.toString();

        for (String letter : alphabet){
            if (str.contains(letter))
                flag = true;           
            else
                flag = false;
        }
        return flag;

    }

    /**
     * @param array array of String objects
     * @param value value to check array for
     * @return number of occurrences the specified `value` has occurred
     */ // TODO
    public static int getNumberOfOccurrences(String[] array, String value) {
        int numberOfOccurences = 0;
        for (int i = 0; i <=array.length-1; i++){
            if (array[i]==value)
                numberOfOccurences+=1;  
        }
        return numberOfOccurences;             
    }

    /**
     * @param array         array of String objects
     * @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 [] strWithoutValue = new String [array.length-1];
        int count = 0;
        for (int i = 0; i < array.length; i++){
            if (!array[i].equals(valueToRemove)){
                strWithoutValue[count]=array[i];
                count += 1;
            }
        }
        return strWithoutValue;         
    }

    /**
     * @param array array of chars
     * @return array of Strings with consecutive duplicates removes
     */ // TODO
    public static String[] removeConsecutiveDuplicates(String[] array) {        
        String [] newArray = new String[array.length];

        int positionOfNewArray = 0;

        for (int i = 0; i <= array.length-2; i++){
            if (!array[i].equals(array[i+1])){
                newArray[positionOfNewArray] = array[i];
                positionOfNewArray+=1;
            }
        }

        newArray[positionOfNewArray] = array[array.length-1];

        String [] finalArray = new String [positionOfNewArray+1];

        for (int i = 0; i< positionOfNewArray+1; i++){
            finalArray[i] = newArray[i];
        }
        return finalArray;
    }

    /**
     * @param array array of chars
     * @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) {

        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < array.length-1; i++){
            if (array[i].equals(array[i+1]))
                sb.append(array[i]);
            else {
                sb.append(array[i]);
                sb.append(" ");
            }
        }
        sb.append(array[array.length-1]);

        String str = sb.toString();
        String [] newArray = str.split(" ");
        return newArray;
    }
}