Mountain

An array of positive integer values has the mountain property if the elements are ordered such that successive values increase until a maximum value (the peak of the mountain) is reached and then the successive values decrease. The Mountain class declaration shown below contains methods that can be used to determine if an array has the mountain property.

You will implement three methods in the Mountain class. For each method, you and your partner will be DRIVER(writing the code) and NAVIGATOR(Offering feedback).

public class Mountain {
    /*
    @param array: an array of positive integer values
    @param stop: the last index to check
    
        Precondition: 0 <= stop < array.length
    
    @return true if for each j such that 0<=j<stop, array[j] < array[j+1]; 
    false otherwise.
    */
    
    public static boolean isIncreasing(int[] array, int stop) {
        for(int i=0; i<stop; i++) {
          /*if previous value is no less than the latter,
          return false since it doesn't increase continuously.  
          */
            if(array[i] >= array[i+1]) return false; 
        }
        return true;
    }
    
    /*
    @param array: an array of positive integer values
    @param start: the first index to check
        
        Precondition: 0 <= start < array.length-1
    
    @return true if for each j such that start<=j<array.length-1, array[j] > array[j+1]; 
    false otherwise.
    */
    
    public static boolean isDecreasing(int[] array, int start) {
        return false;
    }

    /*
    @param array: an array of positive values
        
        Precondition: array.length > 0
    
    @return the index of the first peak(local maximum) in the array, if it exists; -1 otherwise.
    
    */
    public static int getPeakIndex(int[] array) {
        return -1;
    }
    
    /*
    @param array: an array of positive integer values
    
        Precondition: array.length > 0
        
    @return true if array contains values ordered as a mountain; false otherwise.
    
    */
    public static boolean isMountain(int[] array) {
        return false;
    }
    
}

Part(1)

Please decide whom to be the DRIVER or NAVIGATOR.

Complete method isDecreasing(int[] array, int start). The method return true if the mountain decreases continuously from start.

For example,

Parameters	isDecreasing(arr, start)
arr: {1, 2, 3, 2, 1} start: 0	return false, since {1,2,3,2,1} is not decreasing continuously.
arr: {1, 2, 3, 2, 1} start: 2	return true, since {3,2,1} is decreasing continuously.
arr: {1, 2, 3, 3, 1} start: 2	return false, since {3,3,1} is not decreasing continuously.

Mathematically, isDecreasing() returns true if:

for each j such that start<=j<array.length-1, array[j] > array[j+1];

Otherwise return false.

Method IsIncreasing(int[] array, int stop) has been provided for you, which returns true if the mountain increases continuously until the stop. You can refer to it as a hint.

Part(2)

Please change roles now.

Write the Mountain method getPeakIndex. Method getPeakIndex returns the index of the first peak found in the parameter array, if one exists.

A peak is defined as an element whose value is greater than the value of the element immediately before it and is also greater than the value of the element immediately after it.

Method getPeakIndex starts at the beginning of the array and returns the index of the first peak that is found or -1 if no peak is found.

For example, the following table illustrates the results of several calls to getPeakIndex.

Part(3)

Please change roles now.

Write the Mountain method isMountain. Method isMountain returns true if the values in the parameter array are ordered as a mountain; otherwise, it returns false.

The values in array are ordered as a mountain if all three of the following conditions hold.

• There must be a peak.

• The array elements with an index smaller than the peak’s index must appear in increasing order.

• The array elements with an index larger than the peak’s index must appear in decreasing order.

For example, the following table illustrates the results of several calls to isMountain.

You have to call getPeakIndex(), isIncreasing()and isDecreasing() in Part(3) to receive full credit.

TEST

Test class has been provided below:

public class Main
{
	public static void main(String[] args) {
		int[] arr1 = {11,22,33,22,11};
		int[] arr2 = {11,22,11,22,11};
		int[] arr3 = {11,22,33,55,77};
		int[] arr4 = {99,33,55,77,120};
		int[] arr5 = {99,33,55,77,55};
		int[] arr6 = {33,22,11};
		
		System.out.println(Mountain.getPeakIndex(arr1)); //2
		System.out.println(Mountain.getPeakIndex(arr2)); //1
		System.out.println(Mountain.getPeakIndex(arr3)); //-1
		System.out.println(Mountain.getPeakIndex(arr4)); //-1
		System.out.println(Mountain.getPeakIndex(arr5)); //3
		System.out.println(Mountain.getPeakIndex(arr6)); //-1
		
		int[] m1 = {1,2,3,2,1};
		int[] m2 = {1,2,1,2,1};
		int[] m3 = {1,2,3,1,5};
		int[] m4 = {1,4,2,1,0};
		int[] m5 = {9,3,5,7,5};
		int[] m6 = {3,2,1};
		
		System.out.println(Mountain.isMountain(m1)); //true
        	System.out.println(Mountain.isMountain(m2)); //false
		System.out.println(Mountain.isMountain(m3)); //false
		System.out.println(Mountain.isMountain(m4)); //true
		System.out.println(Mountain.isMountain(m5)); //false
		System.out.println(Mountain.isMountain(m6)); //false

	}
}

The result should be like:

2
1
-1
-1
3
-1
true
false
false
true
false
false