Find the Highest Altitude - Practice Coding Problems

Find the Highest Altitude - Problem

Imagine you're tracking a mountain biker's journey through a scenic route with varying elevations. The biker starts at sea level (altitude 0) and travels through n + 1 checkpoints, each at different heights.

You're given an array gain where gain[i] represents the net change in altitude between checkpoint i and checkpoint i + 1. A positive value means going uphill, while a negative value means going downhill.

Your mission: Find the highest altitude the biker reaches during their entire journey.

Example: If gain = [-5, 1, 5, 0, -7], the biker's altitude at each point would be: [0, -5, -4, 1, 1, -6], so the highest altitude reached is 1.

Input & Output

example_1.py — Basic Mountain Route

$ Input: gain = [-5, 1, 5, 0, -7]

› Output: 1

💡 Note: The altitudes are [0, -5, -4, 1, 1, -6]. The highest altitude is 1.

example_2.py — Steady Climb

$ Input: gain = [-4, -3, -2, -1, 4, 3, 2]

› Output: 0

💡 Note: The altitudes are [0, -4, -7, -9, -10, -6, -3, -1]. The highest altitude is 0 (starting point).

example_3.py — Single Step

$ Input: gain = [5]

› Output: 5

💡 Note: The altitudes are [0, 5]. The highest altitude is 5.

Visualization

Tap to expand

Understanding the Visualization

Starting Point

Biker begins at altitude 0 (sea level)

Process Each Segment

Add each altitude gain/loss to current position

Track Maximum

Remember the highest altitude reached so far

Continue Journey

Process all segments while maintaining the maximum

Key Takeaway

🎯 Key Insight: We only need to track the running sum (current altitude) and the maximum value seen so far, making this an optimal O(n) solution using prefix sum technique.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through the gain array exactly once, performing constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only using two variables to track current and maximum altitude

✓ Linear Space

Constraints

n == gain.length
1 ≤ n ≤ 100
-100 ≤ gain[i] ≤ 100

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a prefix sum approach in O(n) time. We track the running altitude as we process each gain value and maintain the maximum altitude seen so far. This eliminates redundant calculations and provides an elegant, efficient solution.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recalculate Each Time)	O(n²)	O(1)	Calculate altitude at each checkpoint by summing gains from the beginning
One-Pass Prefix Sum (Optimal)	O(n)	O(1)	Track running altitude and maximum in a single pass through the array

Brute Force (Recalculate Each Time) — Algorithm Steps

Initialize maximum altitude as 0 (starting point)
For each checkpoint i from 0 to n-1:
Calculate current altitude by summing gain[0] to gain[i]
Update maximum altitude if current altitude is higher
Return the maximum altitude found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at altitude 0

Begin at the starting point with altitude 0

Calculate altitude at checkpoint 1

Sum gains from start: gain[0]

Calculate altitude at checkpoint 2

Sum gains from start: gain[0] + gain[1]

Continue for all checkpoints

Repeat calculation for each checkpoint, always starting from the beginning

Code -

solution.c — C

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

int largestAltitude(int* gain, int gainSize) {
    int maxAltitude = 0; // Starting altitude
    
    // Check altitude at each checkpoint
    for (int i = 0; i < gainSize; i++) {
        int currentAltitude = 0;
        // Calculate altitude by summing all gains up to checkpoint i
        for (int j = 0; j <= i; j++) {
            currentAltitude += gain[j];
        }
        if (currentAltitude > maxAltitude) {
            maxAltitude = currentAltitude;
        }
    }
    
    return maxAltitude;
}

int main() {
    int n;
    scanf("%d", &n);
    int* gain = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &gain[i]);
    }
    printf("%d\n", largestAltitude(gain, n));
    free(gain);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n checkpoints, we sum up to i elements, resulting in roughly n²/2 operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track current and maximum altitude

✓ Linear Space

Constraints

n == gain.length
1 ≤ n ≤ 100
-100 ≤ gain[i] ≤ 100

42.3K Views

Medium Frequency

~8 min Avg. Time

1.9K 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 (Recalculate Each Time) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler