# Check If Given Array Is Monotonic

A monotonic array is an array if it is either increasing or monotonic decreasing.

## Problem Statement

An array `A`

is monotone increasing if for all `i <= j`

, `A[i] <= A[j]`

, where `i`

and `j`

are index elements.

An array `A`

is monotone decreasing if for all `i >= j`

, `A[i] >= A[j]`

. `true`

is returned if and only if the given array `A`

is monotonic.

### Explanation:

** Monotone increasing: **An array

`A`

is called monotone increasing if the first number is less than or equal to the second number, the second number is less than or equal to the third number, and so on, and vice versa.** Monotone decreasing: **An array

`A`

is called monotone decreasing if the first number is greater than or equal to the second number, the second number is greater than or equal to the third number, and so on, and vice versa.**Example 1:**

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

**Example 2:**

```
Â Â Input:Â [1,Â 2,Â 6,Â 2,Â 3]Â Â
Output:Â false
```

**Example 3:**

```
Â Â Input:Â [7,Â 2,Â 1]Â Â
Output:Â true
```

### Thought Process

An array is called monotonic if the index of each element increases from the first to the last or decreases from the first to the last.

### Algorithm

We need to run two for loops to check if either of the loops returns true.

For the monotonic increasing array, we need to check if the previous index is less than the current index. And for the monotonic decreasing array, we need to check if the previous index is greater than the current index.

Finally, we return `true`

if either of the loops evaluates to `true`

.

: we can do using one pass but let us look at both the algorithms.Optimal way

### Solution

### Two-Pass approach

```
class MonotonicArray {
public static void main(String[] args) {
int[] input = {1, 2, 2, 3};
System.out.println(isMonotonic(input)); // true
}
public static boolean isMonotonic(int[] array) {
return isIncreasing(array) || isDecreasing(array);
}
public static boolean isIncreasing(int[] nums) {
for (int i = 1; i < nums.length; i++)
if (nums[i - 1] > nums[i]) {
return false;
}
return true;
}
public static boolean isDecreasing(int[] nums) {
for (int i = 1; i < nums.length; i++)
if (nums[i - 1] < nums[i]) {
return false;
}
return true;
}
}
```

#### Complexity Analysis

We are doing two for loops above; the overall time complexity is ** O(n)**, and the space complexity is

**.**

**O(1)**Let us optimize the above code snippet with a single loop.

### One-Pass approach

```
class MonotonicArray {
public static void main(String[] args) {
int[] input = {1, 2, 2, 3};
System.out.println(isMonotonic(input)); // true
}
public static boolean isMonotonic(int[] array) {
boolean isIncreasing = true;
boolean isDecreasing = true;
for (int i = 1; i < array.length; i++) {
if (array[i] < array[i - 1]) {
isDecreasing = false;
}
if (array[i] > array[i - 1]) {
isIncreasing = false;
}
}
return isIncreasing || isDecreasing;
}
}
```

#### Complexity Analysis

Overall complexity analysis wonâ€™t change, but we are eliminating a loop with this optimized approach.

Hence, the complexity analysis for both approaches is time â€“ ** O(n)** and space â€“

**.**

**O(1)**I have also written a course on how to solve problems using bit manipulation. You can visit it here:Master Bit Manipulation for Coding Interviews.