Maximum Value of an Ordered Triplet I

Maximum Value of an Ordered Triplet I - Problem

Array Easy

You are given a 0-indexed integer array nums.

Return the maximum value over all triplets of indices (i, j, k) such that i < j < k. If all such triplets have a negative value, return 0.

The value of a triplet of indices (i, j, k) is equal to (nums[i] - nums[j]) * nums[k].

Input & Output

Example 1 — Basic Case

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

› Output: 77

💡 Note: The maximum value is achieved at triplet (0,2,4): (12-1)*7 = 11*7 = 77

Example 2 — All Negative

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

› Output: 133

💡 Note: Maximum triplet is (1,2,4): (10-3)*19 = 7*19 = 133

Example 3 — Small Array

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

› Output: 0

💡 Note: Only one triplet (0,1,2): (1-2)*3 = -1*3 = -3, which is negative, so return 0

Constraints

3 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12

The key insight is to recognize that for each position k, we need to find the maximum value of (nums[i] - nums[j]) where i < j < k. The optimal approach uses O(n²) time by tracking the maximum difference efficiently rather than checking all O(n³) triplets. Best approach: Optimized tracking. Time: O(n²), Space: O(1)

Common Approaches

✓ Brute Force - Check All Triplets

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

For every valid triplet of indices, calculate (nums[i] - nums[j]) * nums[k] and track the maximum value. Return 0 if all values are negative.

Optimized - Track Maximum Difference

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

Instead of checking all triplets, for each position k, we maintain the maximum value of (nums[i] - nums[j]) for all valid i < j < k. This reduces the time complexity significantly.

Brute Force - Check All Triplets — Algorithm Steps

Triple nested loop: i from 0 to n-3, j from i+1 to n-2, k from j+1 to n-1
Calculate value = (nums[i] - nums[j]) * nums[k] for each triplet
Track maximum value found
Return max value or 0 if all negative

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Initialize with array and check all i < j < k

Calculate

For each triplet: (nums[i] - nums[j]) * nums[k]

Result

Track maximum value found

Code -

solution.c — C

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

long long solution(int* nums, int n) {
    long long maxValue = LLONG_MIN;
    
    for (int i = 0; i < n - 2; i++) {
        for (int j = i + 1; j < n - 1; j++) {
            for (int k = j + 1; k < n; k++) {
                long long value = (long long)(nums[i] - nums[j]) * nums[k];
                if (value > maxValue) {
                    maxValue = value;
                }
            }
        }
    }
    
    return maxValue < 0 ? 0 : maxValue;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    long long result = solution(nums, n);
    printf("%lld\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Triple nested loops iterate through all possible triplets

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track maximum value

✓ Linear Space

12.0K Views

Medium Frequency

~15 min Avg. Time

245 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

Brute Force - Check All Triplets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler