Maximum Difference Between Increasing Elements

Maximum Difference Between Increasing Elements - Problem

Array Easy

Imagine you're a day trader looking at stock prices throughout a trading day. You have an array of stock prices where each element represents the price at a specific time, and you want to find the maximum profit you can make by buying at one time and selling at a later time.

Given a 0-indexed integer array nums of size n, find the maximum difference between nums[j] - nums[i] such that:

0 ≤ i < j < n (you must buy before you sell)
nums[i] < nums[j] (you can only profit if the price increases)

Return the maximum difference. If no profitable trade exists, return -1.

Example: For prices [7, 1, 5, 3, 6, 4], buying at price 1 and selling at price 6 gives maximum profit of 5.

Input & Output

example_1.py — Basic Increasing Array

$ Input: nums = [7, 1, 5, 3, 6, 4]

› Output: 5

💡 Note: Buy at price 1 (index 1) and sell at price 6 (index 4) for maximum profit of 6 - 1 = 5

example_2.py — No Profit Possible

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

› Output: -1

💡 Note: Array is strictly decreasing, so no valid i < j exists where nums[i] < nums[j]

example_3.py — Small Difference

$ Input: nums = [1, 5, 2, 10]

› Output: 9

💡 Note: Buy at price 1 (index 0) and sell at price 10 (index 3) for maximum profit of 10 - 1 = 9

Constraints

n == nums.length
2 ≤ n ≤ 1000
1 ≤ nums[i] ≤ 10⁹
Must have i < j and nums[i] < nums[j]

Visualization

Tap to expand

Understanding the Visualization

Track Minimum

Keep track of the lowest stock price seen so far (best buying opportunity)

Calculate Profit

For each new price, calculate potential profit if we sell now

Update Maximum

Keep track of the highest profit possible

Key Takeaway

🎯 Key Insight: For any selling day, the optimal buying day is always the day with the lowest price encountered so far. This allows us to solve the problem in a single pass with O(n) time complexity.

Asked in

a Amazon 42 G Google 38 ⊞ Microsoft 31 f Meta 27

The optimal solution uses a one-pass approach that tracks the minimum price seen so far while calculating the maximum profit. The key insight is that for any selling point, the best buying opportunity is always the lowest price encountered previously. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check all possible pairs where i < j and nums[i] < nums[j]
One-Pass Optimal Solution	O(n)	O(1)	Track minimum value seen so far while scanning for maximum difference

Brute Force (Nested Loops) — Algorithm Steps

Use nested loops: outer loop for buying index i, inner loop for selling index j
For each pair (i, j) where i < j, check if nums[i] < nums[j]
If condition is met, calculate difference nums[j] - nums[i]
Keep track of maximum difference found
Return maximum difference or -1 if none found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set up nested loops to compare all pairs

Compare Pairs

For each (i,j) where i<j, check if nums[i]<nums[j]

Track Maximum

Keep track of the maximum difference found

Code -

solution.c — C

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

int maximumDifference(int* nums, int numsSize) {
    int maxDiff = -1;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if (nums[i] < nums[j]) {
                int diff = nums[j] - nums[i];
                if (diff > maxDiff) {
                    maxDiff = diff;
                }
            }
        }
    }
    
    return maxDiff;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[100];
    int count = 0;
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", maximumDifference(nums, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops each running up to n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track maximum difference

✓ Linear Space

89.6K Views

High Frequency

~12 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler