132 Pattern - Problem

Array Binary Search Stack Monotonic Stack Ordered Set Medium

Given an array of n integers nums, a 132 pattern is a subsequence of three integers nums[i], nums[j] and nums[k] such that i < j < k and nums[i] < nums[k] < nums[j].

Return true if there is a 132 pattern in nums, otherwise return false.

Input & Output

Example 1 — Found Pattern

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

› Output: false

💡 Note: No 132 pattern exists. The array is strictly increasing, so no element can satisfy nums[i] < nums[k] < nums[j] with i < j < k.

Example 2 — Valid Pattern

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

› Output: true

💡 Note: Pattern found at indices (1,2,3): nums[1]=1, nums[2]=4, nums[3]=2, and 1 < 2 < 4 forms a 132 pattern.

Example 3 — Decreasing Array

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

› Output: true

💡 Note: Pattern found at indices (0,1,2): nums[0]=-1, nums[1]=3, nums[2]=2, and -1 < 2 < 3 forms a 132 pattern.

Constraints

n == nums.length
1 ≤ n ≤ 2 × 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 M Microsoft 8 f Facebook 6

The key insight is to scan from right to left using a monotonic stack to efficiently track potential '3' values in the 132 pattern. Best approach uses a monotonic stack that maintains decreasing order while tracking the largest valid middle element. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Check All Triplets

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

For each possible combination of three indices where i < j < k, check if nums[i] < nums[k] < nums[j]. This examines all possible subsequences of length 3.

Monotonic Stack (Optimal)

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

Scan the array from right to left, maintaining a monotonic decreasing stack and tracking the largest possible '3' value. For each element that could be '2', check if we have a valid '3' that's greater than the minimum '1' found so far.

Two Pass with Minimum Tracking

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

First pass tracks the minimum value to the left of each position. Second pass iterates from right, maintaining candidates for the '3' position and checking if current element can be the '2' (peak).

Brute Force - Check All Triplets — Algorithm Steps

Iterate through all possible i positions
For each i, iterate through all j > i
For each j, iterate through all k > j
Check if nums[i] < nums[k] < nums[j]

Visualization

Tap to expand

Step-by-Step Walkthrough

Triple Nested Loops

Check all i < j < k combinations

Pattern Check

Verify nums[i] < nums[k] < nums[j]

Return Result

Return true if any triplet matches

Code -

solution.c — C

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

bool solution(int* nums, int numsSize) {
    for (int i = 0; i < numsSize - 2; i++) {
        for (int j = i + 1; j < numsSize - 1; j++) {
            for (int k = j + 1; k < numsSize; k++) {
                if (nums[i] < nums[k] && nums[k] < nums[j]) {
                    return true;
                }
            }
        }
    }
    return false;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    int nums[1000];
    int size = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[size++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    printf(solution(nums, size) ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops iterate through all possible triplets

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

⚡ Linearithmic Space

93.5K Views

Medium Frequency

~25 min Avg. Time

1.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

132 Pattern - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Triplets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler