Monotonic Array - Practice Coding Problems

Monotonic Array - Problem

Array Easy

Imagine you're analyzing data trends - monotonic arrays are sequences that consistently move in one direction, never changing course!

An array is monotonic if it follows one of these patterns:

Monotone Increasing: Each element is greater than or equal to the previous one (nums[i] ≤ nums[j] for all i ≤ j)
Monotone Decreasing: Each element is less than or equal to the previous one (nums[i] ≥ nums[j] for all i ≤ j)

Given an integer array nums, determine if it maintains a monotonic pattern.

Examples:

[1, 2, 2, 3] → true (increasing)
[6, 5, 4, 4] → true (decreasing)
[1, 3, 2] → false (changes direction)

Input & Output

example_1.py — Python

$ Input: [1,2,2,3]

› Output: true

💡 Note: The array is monotone increasing (non-decreasing). Each element is greater than or equal to the previous one.

example_2.py — Python

$ Input: [6,5,4,4]

› Output: true

💡 Note: The array is monotone decreasing (non-increasing). Each element is less than or equal to the previous one.

example_3.py — Python

$ Input: [1,3,2]

› Output: false

💡 Note: The array changes direction: increases from 1 to 3, then decreases from 3 to 2. It's neither monotone increasing nor decreasing.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁵ ≤ nums[i] ≤ 10⁵
Edge cases: Single element or empty arrays are considered monotonic

Visualization

Tap to expand

Understanding the Visualization

Trend Detection

As we scan through daily prices, we note any increases or decreases

Pattern Recognition

If we see both upward AND downward movements, the stock is volatile (not monotonic)

Early Warning

The moment we detect mixed trends, we know it's not a consistent pattern

Key Takeaway

🎯 Key Insight: We only need to track if we've seen BOTH increasing and decreasing trends. If we see both, it's not monotonic - just like a volatile stock that goes both up and down!

Asked in

f Facebook 45 G Google 38 a Amazon 32 ⊞ Microsoft 28

The optimal approach uses single-pass trend tracking with O(n) time complexity. We maintain two boolean flags to track increasing and decreasing trends. If both trends are detected during our scan, the array cannot be monotonic. This elegant solution provides early termination and minimal space usage.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Pairs Check)	O(n²)	O(1)	Check every pair of elements to verify monotonic property
One Pass Trend Tracking (Optimal)	O(n)	O(1)	Track increasing and decreasing trends in a single pass through the array

Brute Force (All Pairs Check) — Algorithm Steps

Check if array is monotone increasing by verifying nums[i] ≤ nums[j] for all i ≤ j
Check if array is monotone decreasing by verifying nums[i] ≥ nums[j] for all i ≤ j
Return true if either condition is satisfied

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Increasing

For each pair (i,j), verify nums[i] ≤ nums[j]

Early Termination

If any pair violates the condition, try decreasing check

Check Decreasing

For each pair (i,j), verify nums[i] ≥ nums[j]

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

bool isMonotonic(int* nums, int numsSize) {
    // Check if monotone increasing
    bool isIncreasing = true;
    for (int i = 0; i < numsSize && isIncreasing; i++) {
        for (int j = i; j < numsSize; j++) {
            if (nums[i] > nums[j]) {
                isIncreasing = false;
                break;
            }
        }
    }
    
    if (isIncreasing) return true;
    
    // Check if monotone decreasing
    bool isDecreasing = true;
    for (int i = 0; i < numsSize && isDecreasing; i++) {
        for (int j = i; j < numsSize; j++) {
            if (nums[i] < nums[j]) {
                isDecreasing = false;
                break;
            }
        }
    }
    
    return isDecreasing;
}

int main() {
    int nums[1000];
    int count = 0;
    char c;
    int num = 0;
    bool inNumber = false;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            inNumber = true;
        } else if (c == '-' && !inNumber) {
            num = 0;
            inNumber = true;
        } else if (inNumber) {
            nums[count++] = num;
            num = 0;
            inNumber = false;
        }
    }
    if (inNumber) nums[count++] = num;
    
    printf("%s\n", isMonotonic(nums, count) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check all pairs (i,j) where i ≤ j, which is approximately n²/2 comparisons

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables regardless of input size

✓ Linear Space

96.2K Views

Medium Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (All Pairs Check) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler