Finding the Number of Visible Mountains - Practice Coding Problems

Finding the Number of Visible Mountains - Problem

Imagine you're standing on a vast plain looking at a range of perfectly triangular mountains. Each mountain has a unique peak and forms a right-angled isosceles triangle with its base on the ground.

You are given a 2D array peaks where peaks[i] = [xi, yi] represents the coordinates of mountain i's peak at position (xi, yi). Each mountain has:

Its base along the x-axis
A right angle at its peak
Slopes of exactly +1 (ascending) and -1 (descending)

A mountain is visible if its peak is not completely hidden inside another mountain (touching the border counts as hidden). Your task is to determine how many mountains you can actually see from your vantage point.

Goal: Return the number of visible mountains.

Input & Output

example_1.py — Basic Case

$ Input: peaks = [[2,2],[6,3],[5,4]]

› Output: 2

💡 Note: Mountain at (2,2) covers x-axis [0,4]. Mountain at (6,3) covers [3,9]. Mountain at (5,4) covers [1,9]. The peak (6,3) is inside mountain (5,4) since 1 < 6 < 9 and 3 ≤ 4, so it's hidden. Mountains at (2,2) and (5,4) are visible.

example_2.py — All Visible

$ Input: peaks = [[1,3],[1,3]]

› Output: 1

💡 Note: Both peaks are identical at (1,3), so we only count unique mountains. After removing duplicates, only 1 mountain remains, which is obviously visible.

example_3.py — Complete Coverage

$ Input: peaks = [[0,1],[1,0]]

› Output: 1

💡 Note: Mountain at (0,1) covers x-axis [-1,1]. Mountain at (1,0) covers [1,1] (just a point). The second peak (1,0) is on the boundary of the first mountain, which counts as hidden. Only the first mountain is visible.

Constraints

1 ≤ peaks.length ≤ 10⁵
peaks[i].length == 2
0 ≤ xi, yi ≤ 10⁵
Each mountain forms a right-angled isosceles triangle

Visualization

Tap to expand

Understanding the Visualization

Map Mountains

Each mountain (x,y) creates a triangle covering ground from x-y to x+y

Check Coverage

A mountain is hidden if its peak lies inside another mountain's triangle

Count Visible

Only mountains not completely covered by others remain visible

Key Takeaway

🎯 Key Insight: Transform peaks into base intervals and use containment relationships - a mountain is visible if no other mountain completely covers its interval with equal or greater height.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

This problem requires understanding geometric relationships between triangular mountains. The key insight is that each mountain with peak (x,y) covers the x-axis interval [x-y, x+y]. A mountain is visible if no other mountain completely contains its coverage area with equal or greater height. The optimal approach uses geometric analysis to convert peaks into intervals and check containment relationships efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Geometric Analysis	O(n²)	O(n)	Sort mountains and use geometric properties to efficiently determine visibility
Brute Force (Compare All Pairs)	O(n²)	O(1)	Check each mountain against every other mountain to see if it's hidden

Sorting + Geometric Analysis — Algorithm Steps

Remove duplicate peaks
Convert each mountain to its base interval [left, right] where left=x-y, right=x+y
Sort mountains by left boundary, then by right boundary descending
For each mountain, check if any previous mountain completely covers it
A mountain is covered if there exists another with left1≤left2, right1≥right2, and height1≥height2

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Intervals

Each mountain (x,y) becomes interval [x-y, x+y]

Sort Mountains

Sort by left boundary for efficient processing

Check Coverage

Mountain A is hidden if another mountain B completely covers A's interval with height≥A's height

Code -

solution.c — C

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

typedef struct {
    int left, right, height;
} Mountain;

int compare(const void* a, const void* b) {
    Mountain* m1 = (Mountain*)a;
    Mountain* m2 = (Mountain*)b;
    if (m1->left != m2->left) {
        return m1->left - m2->left;
    }
    return m2->right - m1->right;
}

int numPointsInMountains(int peaks[][2], int n) {
    Mountain mountains[n];
    
    // Convert to intervals
    for (int i = 0; i < n; i++) {
        int x = peaks[i][0], y = peaks[i][1];
        mountains[i].left = x - y;
        mountains[i].right = x + y;
        mountains[i].height = y;
    }
    
    // Sort
    qsort(mountains, n, sizeof(Mountain), compare);
    
    int visibleCount = 0;
    
    for (int i = 0; i < n; i++) {
        bool isVisible = true;
        
        for (int j = 0; j < n; j++) {
            if (i == j) continue;
            
            if (mountains[j].left <= mountains[i].left && 
                mountains[i].right <= mountains[j].right && 
                mountains[j].height >= mountains[i].height) {
                isVisible = false;
                break;
            }
        }
        
        if (isVisible) {
            visibleCount++;
        }
    }
    
    return visibleCount;
}

int main() {
    int n;
    scanf("%d", &n);
    int peaks[n][2];
    for (int i = 0; i < n; i++) {
        scanf("%d %d", &peaks[i][0], &peaks[i][1]);
    }
    printf("%d\n", numPointsInMountains(peaks, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n log n) for sorting plus O(n²) for checking coverage in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing processed mountains and sorting

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

945 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

Sorting + Geometric Analysis — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler