# The Valid Mountain Array Problem using Java

## Introducing the problem

Given an array `A` of integers, return `true` if and only if it is a valid mountain array.

Recall that A is a mountain array if and only if:

• `A.length >= 3`
• There exists some `i` with `0 < i < A.length - 1` such that:
• `A[0] < A[1] < ... A[i-1] < A[i]`
• `A[i] > A[i+1] > ... > A[A.length - 1]`

## The constraints

Example 1:

```Input: [2,1]
Output: false```

Example 2:

```Input: [3,5,5]
Output: false```

Example 3:

```Input: [0,3,2,1]
Output: true```

Note:

1. `0 <= A.length <= 10000`
2. `0 <= A[i] <= 10000 `

## How to solve this in Java

```.wp-block-code {
border: 0;
}

.wp-block-code > div {
overflow: auto;
}

.shcb-language {
border: 0;
clip: rect(1px, 1px, 1px, 1px);
-webkit-clip-path: inset(50%);
clip-path: inset(50%);
height: 1px;
margin: -1px;
overflow: hidden;
position: absolute;
width: 1px;
word-wrap: normal;
word-break: normal;
}

.hljs {
box-sizing: border-box;
}

.hljs.shcb-code-table {
display: table;
width: 100%;
}

.hljs.shcb-code-table > .shcb-loc {
color: inherit;
display: table-row;
width: 100%;
}

.hljs.shcb-code-table .shcb-loc > span {
display: table-cell;
}

.wp-block-code code.hljs:not(.shcb-wrap-lines) {
white-space: pre;
}

.wp-block-code code.hljs.shcb-wrap-lines {
white-space: pre-wrap;
}

.hljs.shcb-line-numbers {
border-spacing: 0;
counter-reset: line;
}

.hljs.shcb-line-numbers > .shcb-loc {
counter-increment: line;
}

.hljs.shcb-line-numbers .shcb-loc > span {
}

.hljs.shcb-line-numbers .shcb-loc::before {
border-right: 1px solid #ddd;
content: counter(line);
display: table-cell;
text-align: right;
-webkit-user-select: none;
-moz-user-select: none;
-ms-user-select: none;
user-select: none;
white-space: nowrap;
width: 1%;
}
```class Solution {
// Input array of integers
public boolean validMountainArray(int[] A) {
// if we have less than 3 integers, it will always be false
if (A.length<3) return false;

// set our counter variables
int len = A.length;
int i = ;

// walk up the array until it decreases
while (i+1 < len && A[i]<A[i+1])
// increment our counter
i++;

// if the start or end characters are the same as our counter
// then the mountain didn't decrease
if (i== || i==len-1)
return false;

// walk the array while it decreases
// starting at the last counter index
while (i+1 < len && A[i]>A[i+1])
i++;

// return a boolean if the counter is the same as the length
return i == len-1;

}
}
```Code language: Java (java)```