#896

Easy

auto_awesomeArray-driven solution strategy

LeetCode Problem Workspace

Monotonic Array

Determine if an integer array is entirely monotone increasing or decreasing using a clear array-driven approach.

Problem Statement

Given an integer array nums, your task is to determine whether it is monotonic. An array is monotonic if it is entirely non-increasing or non-decreasing across its elements. Return true if nums is monotonic, or false otherwise.

Monotone increasing means every element is less than or equal to the next element, and monotone decreasing means every element is greater than or equal to the next. Evaluate the array carefully since even one violation of the trend makes it non-monotonic.

Examples

Example 1

Input: nums = [1,2,2,3]

Output: true

Example details omitted.

Example 2

Input: nums = [6,5,4,4]

Output: true

Example details omitted.

Example 3

Input: nums = [1,3,2]

Output: false

Example details omitted.

Constraints

1 <= nums.length <= 105
-105 <= nums[i] <= 105

Solution Approach

Single-Pass Trend Tracking

Initialize two boolean flags, isIncreasing and isDecreasing. Traverse the array once, updating these flags whenever a pair violates an expected trend. Return true if at least one trend remains valid at the end.

Two-Pointer Comparison

Use pointers i and i+1 to scan through the array. Compare each pair to detect violations of monotonicity. This method closely follows the array-driven pattern and quickly identifies non-monotonic elements.

Early Exit on Violation

Optimize by returning false immediately when both increasing and decreasing flags are false. This reduces unnecessary comparisons and keeps the solution efficient for large arrays.

Complexity Analysis

Metric	Value
Time	Depends on the final approach
Space	Depends on the final approach

Time complexity is O(n) since each element is visited once in a linear scan. Space complexity is O(1) because only two flags are stored regardless of array size.

What Interviewers Usually Probe

Watch for off-by-one errors when comparing adjacent elements in the array.
Check edge cases like arrays with all identical elements or a single element.
Be ready to explain why a linear pass is sufficient instead of nested loops.

Common Pitfalls or Variants

Common pitfalls

Assuming strictly increasing or decreasing rather than non-strict comparisons.
Forgetting to handle arrays with only one element correctly.
Overcomplicating with extra data structures instead of simple flags.

Follow-up variants

Determine the longest monotonic prefix of an array.
Count the number of monotonic subarrays of length at least two.
Check monotonicity only for odd- or even-indexed elements.

FAQ

What defines a monotonic array in LeetCode problem 896?

An array is monotonic if it is entirely non-increasing or non-decreasing, meaning no element reverses the overall trend.

Can GhostInterview help spot array trends quickly?

Yes, it flags violations in the monotonic trend while scanning, saving you time in checking each adjacent pair.

How do I handle arrays with all identical elements?

Arrays with identical elements are considered monotonic because they do not violate increasing or decreasing trends.

Is a single-pass approach always sufficient for monotonic arrays?

Yes, a single linear pass with trend flags is enough to determine monotonicity, ensuring optimal O(n) performance.

What mistakes should I avoid when checking monotonicity?

Avoid assuming strict inequality, forgetting single-element arrays, and adding unnecessary data structures instead of simple flags.

terminal

Solution

Solution 1: Single Traversal

We traverse the array, and if an increasing or decreasing situation occurs, we record it. We then check whether both increasing and decreasing situations have occurred. If both have occurred, it means that the array is not monotonic, and we return `false`.

1

2

3

4

5

class Solution:
    def isMonotonic(self, nums: List[int]) -> bool:
        asc = all(a <= b for a, b in pairwise(nums))
        desc = all(a >= b for a, b in pairwise(nums))
        return asc or desc

Continue Practicing

#898 bitwise ors of subarrays #893 groups of special equivalent strings #892 surface area of 3d shapes