Maximum Width Ramp - Practice Coding Problems

Maximum Width Ramp - Problem

Imagine you're looking at an array of numbers where you need to find the widest ramp possible!

A ramp in an integer array nums is a pair of indices (i, j) where:

i < j (left index comes before right index)
nums[i] <= nums[j] (left value is less than or equal to right value)

The width of such a ramp is simply j - i (the distance between the indices).

Goal: Given an integer array nums, return the maximum width of a ramp. If no ramp exists, return 0.

Example: In array [6,0,8,2,1,5], we can form a ramp from index 1 (value 0) to index 5 (value 5), giving us a width of 4!

Input & Output

example_1.py — Basic Ramp

$ Input: [6,0,8,2,1,5]

› Output: 4

💡 Note: The maximum width ramp is from index 1 (value 0) to index 5 (value 5), giving width 5-1=4. Other valid ramps exist like (1,2), (1,3), (1,5), (4,5) but none are wider.

example_2.py — Decreasing Array

$ Input: [9,8,1,0,1,9,4,0,4,1]

› Output: 7

💡 Note: The maximum width ramp is from index 2 (value 1) to index 9 (value 1), giving width 9-2=7. Even though values are equal, it still forms a valid ramp since 1 <= 1.

example_3.py — No Ramp Possible

$ Input: [10,9,8,7,6,5,4,3,2,1]

› Output: 0

💡 Note: This is a strictly decreasing array, so no ramp exists where nums[i] <= nums[j] with i < j. Every element is greater than all elements that come after it.

Visualization

Tap to expand

Understanding the Visualization

Identify Strategic Points

Mark all potential starting points (decreasing heights from left)

Scan from Right

Starting from rightmost point, find the longest bridge possible

Build Maximum Bridge

Connect the farthest valid points for maximum span

Key Takeaway

🎯 Key Insight: Use a decreasing monotonic stack to efficiently identify the best starting points, then scan backwards to find the maximum width ramp in linear time!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We have nested loops where outer loop runs n-1 times and inner loop runs up to n-1 times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track the maximum width

✓ Linear Space

Constraints

2 ≤ nums.length ≤ 5 × 10⁴
0 ≤ nums[i] ≤ 5 × 10⁴
Array contains at least 2 elements

Asked in

G Google 42 a Amazon 38 Apple 25 ⊞ Microsoft 22

The optimal solution uses a monotonic decreasing stack in O(n) time. First pass builds a stack of potential left endpoints (indices with decreasing values). Second pass scans right-to-left, popping from stack when valid ramps are found. This approach is much more efficient than brute force O(n²) or sorting-based O(n log n) solutions.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible pair (i,j) where i < j and nums[i] <= nums[j]
Two Pointers with Sorted Indices	O(n log n)	O(n)	Sort indices by values and use two pointers to find maximum width
Monotonic Stack (Optimal)	O(n)	O(n)	Use decreasing monotonic stack to find potential left endpoints, then scan right-to-left

Brute Force (Nested Loops) — Algorithm Steps

Initialize maxWidth to 0
For each index i from 0 to n-2
For each index j from i+1 to n-1
If nums[i] <= nums[j], update maxWidth with max(maxWidth, j-i)
Return maxWidth

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from index 0

Check all pairs starting from index 0

Move to index 1

Check all pairs starting from index 1

Continue until end

Keep track of maximum width found

Code -

solution.c — C

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

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

int main() {
    int nums[] = {6, 0, 8, 2, 1, 5};
    int size = 6;
    printf("%d\n", maxWidthRamp(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We have nested loops where outer loop runs n-1 times and inner loop runs up to n-1 times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track the maximum width

✓ Linear Space

Constraints

2 ≤ nums.length ≤ 5 × 10⁴
0 ≤ nums[i] ≤ 5 × 10⁴
Array contains at least 2 elements

78.3K Views

Medium Frequency

~22 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler