Monotonic Array

Monotonic Array - Problem

Array Easy

An array is monotonic if it is either monotone increasing or monotone decreasing.

An array nums is monotone increasing if for all i <= j, nums[i] <= nums[j].

An array nums is monotone decreasing if for all i <= j, nums[i] >= nums[j].

Given an integer array nums, return true if the given array is monotonic, or false otherwise.

Input & Output

Example 1 — Non-decreasing Array

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

› Output: true

💡 Note: Array is non-decreasing: 1 ≤ 2 ≤ 2 ≤ 3. Since it satisfies the monotonic increasing property, return true.

Example 2 — Non-monotonic Array

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

› Output: true

💡 Note: Array is non-increasing: 6 ≥ 5 ≥ 4 ≥ 4. Since it satisfies the monotonic decreasing property, return true.

Example 3 — Mixed Pattern

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

› Output: false

💡 Note: Array has both increasing (1<3) and decreasing (3>2) transitions, so it's not monotonic.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁵ ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

F Facebook 28 a Amazon 15 G Google 12

The key insight is that an array is monotonic if it never has both increasing AND decreasing transitions. The optimal single-pass approach tracks both patterns simultaneously and returns false immediately when both are detected. Time: O(n), Space: O(1).

Common Approaches

✓ Single Pass - Track Violations

⏱️ Time: O(n) Space: O(1)

One pass tracking if we've seen both increases and decreases

Two Pass - Separate Checks

⏱️ Time: O(n) Space: O(1)

Make one pass checking for increasing, another for decreasing

Brute Force - Check All Pairs

⏱️ Time: O(n²) Space: O(1)

Check every pair (i,j) where i <= j to verify monotonic property

Single Pass - Track Violations — Algorithm Steps

Initialize flags for seen increases and decreases
Traverse array once, comparing adjacent elements
Track increases (nums[i] < nums[i+1]) and decreases (nums[i] > nums[i+1])
Return false if both increases and decreases are seen

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set increasing=false, decreasing=false

Traverse

Compare adjacent elements and update flags

Early Exit

Return false immediately if both patterns detected

Code -

solution.c — C

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

bool solution(int* nums, int numsSize) {
    if (numsSize <= 1) return true;
    
    bool increasing = false;
    bool decreasing = false;
    
    for (int i = 0; i < numsSize - 1; i++) {
        if (nums[i] < nums[i + 1]) {
            increasing = true;
        } else if (nums[i] > nums[i + 1]) {
            decreasing = true;
        }
        
        // Early termination: if both patterns seen, not monotonic
        if (increasing && decreasing) {
            return false;
        }
    }
    
    return true;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int nums[1000];
    int size = 0;
    
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* token = strtok(ptr, ",]");
        while (token != NULL) {
            nums[size++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    bool result = solution(nums, size);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, comparing adjacent elements once

✓ Linear Growth

Space Complexity

O(1)

Only uses two boolean flags to track increase/decrease patterns

✓ Linear Space

180.0K Views

Medium Frequency

~15 min Avg. Time

2.2K 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

Single Pass - Track Violations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler