# 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).
```java
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= 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[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\[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:
```java
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
```
