Increasing Triplet Subsequence - Practice Coding Problems

Increasing Triplet Subsequence - Problem

Array Greedy Medium

You're given an integer array nums, and your task is to determine if there exists an increasing triplet subsequence.

Specifically, you need to find three indices i, j, and k such that:

i < j < k (indices are in order)
nums[i] < nums[j] < nums[k] (values are strictly increasing)

Return true if such a triplet exists, false otherwise.

Key insight: You don't need to find the actual triplet - just determine if one exists! This opens up opportunities for space-efficient solutions.

Example: In array [1, 2, 3, 4, 5], we can pick indices 0, 1, 2 where 1 < 2 < 3, so return true.

Input & Output

example_1.py — Basic Increasing Sequence

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

› Output: true

💡 Note: Multiple valid triplets exist: (1,2,3), (1,2,4), (2,3,4), etc. Any three consecutive or non-consecutive elements work since the array is strictly increasing.

example_2.py — No Valid Triplet

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

› Output: false

💡 Note: Array is strictly decreasing, so no increasing triplet can exist. Every element is smaller than the previous ones.

example_3.py — Mixed Pattern

$ Input: [2,1,1,0,4,2,6]

› Output: true

💡 Note: Valid triplet exists: indices (3,4,6) give us values (0,4,6) where 0 < 4 < 6. The key insight is that we don't need consecutive elements.

Visualization

Tap to expand

Understanding the Visualization

Deploy Scouts

Start with both scouts at 'infinity height' - they haven't found any peaks yet

First Scout Updates

When you find a peak lower than first scout's peak, send first scout there

Second Scout Updates

When you find a peak higher than first but lower than second, send second scout there

Victory Condition

When you find any peak higher than second scout's position, you've found your ascending triplet!

Key Takeaway

🎯 Key Insight: By maintaining the most promising 'first' and 'second' candidates, we can detect any increasing triplet in a single pass without storing the entire sequence!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element processed once

✓ Linear Growth

Space Complexity

O(1)

Only using two variables regardless of input size

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 5 × 10⁵
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
Follow-up: Could you implement a solution that runs in O(n) time complexity and O(1) space complexity?

Asked in

G Google 42 f Facebook 38 a Amazon 35 ⊞ Microsoft 28

The optimal solution uses a greedy approach with two variables: first tracks the smallest element seen, and second tracks the smallest element greater than first. When any element exceeds second, we've found our increasing triplet. This achieves O(n) time and O(1) space complexity through clever state tracking.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check all possible triplets with three nested loops
Greedy Two-Variable Tracking (Optimal)	O(n)	O(1)	Track the smallest 'first' and 'second' elements in a single pass

Brute Force (Triple Nested Loops) — Algorithm Steps

Use first loop for index i (0 to n-3)
Use second loop for index j (i+1 to n-2)
Use third loop for index k (j+1 to n-1)
Check if nums[i] < nums[j] < nums[k]
Return true immediately if condition is met
Return false if no valid triplet found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Start with i=0, j=1, k=2

Check Current Triplet

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

Move Inner Pointers

Increment k, then j, then i systematically

Continue Until Found

Return true when valid triplet found, or false if exhausted

Code -

solution.c — C

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

bool increasingTriplet(int* nums, int numsSize) {
    // Check all possible triplets
    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[j] && nums[j] < nums[k]) {
                    return true;
                }
            }
        }
    }
    
    return false;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[1000];
    int count = 0;
    char* token = strtok(input, "[,] \n");
    while (token != NULL && count < 1000) {
        nums[count++] = atoi(token);
        token = strtok(NULL, "[,] \n");
    }
    
    printf("%s\n", increasingTriplet(nums, count) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops, each potentially iterating through most of the array

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a constant amount of extra variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 5 × 10⁵
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
Follow-up: Could you implement a solution that runs in O(n) time complexity and O(1) space complexity?

73.3K Views

High Frequency

~15 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

Brute Force (Triple Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler