132 Pattern - Practice Coding Problems

132 Pattern - Problem

Array Binary Search Stack Monotonic Stack Ordered Set Medium

You're given an array of integers, and your mission is to find a special pattern called a 132 pattern. This pattern consists of three elements at positions i, j, and k where:

i < j < k (they appear in this order in the array)
nums[i] < nums[k] < nums[j] (the values follow a 1-3-2 relationship)

Think of it as finding a "dip and recover" pattern: a small number, followed by a large peak, then a medium number that's between them.

Example: In array [1, 2, 3, 4], there's no 132 pattern. But in [3, 1, 4, 2], we have 1 < 2 < 4 forming our 132 pattern!

Goal: Return true if such a pattern exists, false otherwise.

Input & Output

example_1.py — Basic Pattern Found

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

› Output: false

💡 Note: No 132 pattern exists. The array is strictly increasing, so we cannot find i < j < k where nums[i] < nums[k] < nums[j].

example_2.py — Pattern Exists

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

› Output: true

💡 Note: 132 pattern found: i=1, j=2, k=3 where nums[1]=1, nums[2]=4, nums[3]=2, and 1 < 2 < 4 satisfies the pattern.

example_3.py — Decreasing Array

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

› Output: true

💡 Note: 132 pattern found: i=0, j=1, k=2 where nums[0]=-1, nums[1]=3, nums[2]=2, and -1 < 2 < 3 satisfies the pattern.

Visualization

Tap to expand

Understanding the Visualization

Scan Market History

Look at price data from most recent to oldest (right to left scanning)

Track Peak Prices

Use a stack to remember significant peak prices in descending order

Identify Sell Points

When a new peak appears, previous peaks become potential sell points

Find Entry Point

Look for prices lower than our best sell point - that's our 132 pattern!

Key Takeaway

🎯 Key Insight: Scan right-to-left using a monotonic stack to efficiently track potential peaks while maintaining the best middle value for pattern detection.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped from stack at most once, so amortized O(n)

✓ Linear Growth

Space Complexity

O(n)

In worst case, all elements could be stored in the stack

⚡ Linearithmic Space

Constraints

n == nums.length
1 ≤ n ≤ 2 × 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹
The array can contain duplicate values

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal solution uses a monotonic stack approach with O(n) time complexity. By scanning from right to left, we maintain potential peaks in a decreasing stack while tracking the largest valid middle value. The key insight is that when we find an element smaller than our tracked middle value, we've discovered a 132 pattern.

Common Approaches

Approach	Time	Space	Notes
✓ Monotonic Stack (Optimal)	O(n)	O(n)	Use stack to track candidates while maintaining the best middle value
Binary Search with Preprocessing	O(n log n)	O(n)	Precompute minimum prefixes and use binary search to find valid middle elements
Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check all possible triplets to find the 132 pattern

Monotonic Stack (Optimal) — Algorithm Steps

Initialize a stack and a variable 'third' to track the best middle value (nums[k])
Scan the array from right to left (this will be our j pointer)
For each position j, if nums[j] > third, we might have found a 132 pattern
While stack is not empty and nums[j] > stack.top(), pop elements and update 'third'
Push current nums[j] to stack
If we find any nums[i] < third during our scan, return true
If no pattern found after complete scan, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty stack and third = -∞, scan from right to left

Process each element

For each element, check if it's smaller than 'third' (found pattern!)

Update stack

Pop smaller elements from stack and update 'third' to maintain monotonic property

Push current

Add current element to stack as potential nums[j]

Code -

solution.c — C

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

bool find132pattern(int* nums, int numsSize) {
    if (numsSize < 3) return false;
    
    int* stack = (int*)malloc(numsSize * sizeof(int));
    int top = -1;
    int third = INT_MIN;  // This represents nums[k] in our 132 pattern
    
    // Scan from right to left
    for (int i = numsSize - 1; i >= 0; i--) {
        // If current number is less than third, we found 132 pattern
        if (nums[i] < third) {
            free(stack);
            return true;
        }
        
        // Maintain decreasing monotonic stack
        while (top >= 0 && nums[i] > stack[top]) {
            third = stack[top];  // Update nums[k] to be as large as possible
            top--;
        }
        
        stack[++top] = nums[i];  // Current element becomes potential nums[j]
    }
    
    free(stack);
    return false;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped from stack at most once, so amortized O(n)

✓ Linear Growth

Space Complexity

O(n)

In worst case, all elements could be stored in the stack

⚡ Linearithmic Space

Constraints

n == nums.length
1 ≤ n ≤ 2 × 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹
The array can contain duplicate values

67.3K Views

Medium-High 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Monotonic Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler