Maximum Value of an Ordered Triplet I - Practice Coding Problems

Maximum Value of an Ordered Triplet I - Problem

Array Easy

You're given a 0-indexed integer array nums and need to find the maximum value among all possible ordered triplets.

An ordered triplet consists of three indices (i, j, k) where i < j < k. The value of such a triplet is calculated as:

(nums[i] - nums[j]) * nums[k]

Goal: Return the maximum value over all valid triplets. If all triplets have negative values, return 0.

Example: For array [12, 6, 1, 2, 7], the triplet (0, 2, 4) gives us (12 - 1) * 7 = 77, which might be our maximum!

Input & Output

example_1.py — Basic Positive Result

$ Input: [12, 6, 1, 2, 7]

› Output: 77

💡 Note: The optimal triplet is (i=0, j=2, k=4): (12 - 1) × 7 = 11 × 7 = 77. This gives the maximum value among all possible ordered triplets.

example_2.py — All Negative Values

$ Input: [1, 10, 3, 4, 19]

› Output: 133

💡 Note: The optimal triplet is (i=4, j=1, k=4) - wait, that's invalid since i < j < k must hold. Actually, it's (i=0, j=1, k=4): (1 - 10) × 19 = -9 × 19 = -171, which is negative. Let's try (i=1, j=2, k=4): (10 - 3) × 19 = 7 × 19 = 133.

example_3.py — Minimum Length Array

$ Input: [2, 3, 1]

› Output: 0

💡 Note: Only one possible triplet: (i=0, j=1, k=2) gives us (2 - 3) × 1 = -1 × 1 = -1, which is negative. Since all triplet values are negative, we return 0.

Visualization

Tap to expand

Understanding the Visualization

Track Best Buy Price

As you move through time, remember the highest price you could have bought at (max_i)

Track Best Profit Potential

For each selling opportunity, calculate potential profit and remember the best (max_diff)

Apply Market Multiplier

When you reach each multiplier day, calculate final return using best profit × multiplier

Key Takeaway

🎯 Key Insight: By maintaining running maximums of the best buy price and best profit potential, we can find the optimal triplet in a single pass through the array, achieving O(n) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, constant work per element

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track running maximums

✓ Linear Space

Constraints

3 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
All array elements are positive integers
Array indices must satisfy i < j < k for valid triplets

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal O(n) solution uses dynamic programming principles to track the maximum nums[i] and maximum (nums[i] - nums[j]) values seen so far. As we iterate through each potential nums[k], we can immediately calculate the best possible triplet value using our tracked maximums, achieving linear time complexity with constant space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check all possible triplets with three nested loops
Two-Pass Optimization	O(n²)	O(n)	Precompute maximum differences, then find optimal multipliers
One-Pass Optimization (Optimal)	O(n)	O(1)	Track maximum values dynamically in a single pass

Brute Force (Triple Nested Loops) — Algorithm Steps

Use three nested loops with i < j < k constraints
For each valid triplet, calculate (nums[i] - nums[j]) * nums[k]
Keep track of the maximum value found
Return max value or 0 if all are negative

Visualization

Tap to expand

Step-by-Step Walkthrough

Outer Loop (i)

Fix the first index i and explore all j > i

Middle Loop (j)

For each i, fix j and explore all k > j

Inner Loop (k)

Calculate (nums[i] - nums[j]) * nums[k] and update maximum

Code -

solution.c — C

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

long long maximumTripletValue(int* nums, int n) {
    long long maxVal = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            for (int k = j + 1; k < n; k++) {
                long long value = (long long)(nums[i] - nums[j]) * nums[k];
                if (value > maxVal) {
                    maxVal = value;
                }
            }
        }
    }
    
    return maxVal;
}

int main() {
    int nums[1000];
    int n = 0;
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Parse array from input
    char* token = strtok(input, "[],");
    while (token != NULL && n < 1000) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    printf("%lld\n", maximumTripletValue(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops, each potentially running n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track maximum value

✓ Linear Space

Constraints

3 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
All array elements are positive integers
Array indices must satisfy i < j < k for valid triplets

28.4K Views

Medium Frequency

~15 min Avg. Time

842 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