Maximum Number of Visible Points - Practice Coding Problems

Maximum Number of Visible Points - Problem

Imagine you're standing at a fixed position on a battlefield with a limited field of view, trying to spot as many enemy targets as possible by rotating your vision. This is exactly what this geometric optimization problem asks you to solve!

You are given:

An array points representing target coordinates on a 2D plane
Your fixed location = [posx, posy] from which you cannot move
An angle representing your field of view in degrees

The Challenge: Initially facing east, you can rotate to any direction d (measured counterclockwise from east). Your field of view spans [d - angle/2, d + angle/2]. Find the maximum number of points you can see by choosing the optimal rotation.

Key Rules:

Points at your exact location are always visible
Multiple points can exist at the same coordinate
Points don't obstruct each other
You need to find the angle of each point relative to your position

Input & Output

example_1.py — Basic Case

$ Input: points = [[2,1],[2,2],[3,3]], angle = 90, location = [1,1]

› Output: 3

💡 Note: With a 90° field of view from position [1,1], we can rotate to see all 3 points simultaneously. The optimal rotation captures points at angles that all fall within a 90° viewing window.

example_2.py — Points at Same Location

$ Input: points = [[2,1],[2,2],[3,4],[1,1]], angle = 90, location = [1,1]

› Output: 4

💡 Note: One point is at our exact location [1,1], so it's always visible. The other 3 points can also be seen within a 90° field of view, giving us a total of 4 visible points.

example_3.py — Narrow Field of View

$ Input: points = [[1,0],[2,1]], angle = 13, location = [1,1]

› Output: 1

💡 Note: With only a 13° field of view, we cannot see both points simultaneously. The angles between the points and our location differ by more than 13°, so we can see at most 1 point at a time.

Constraints

1 ≤ points.length ≤ 10³
points[i].length == 2
location.length == 2
-10⁹ ≤ x_i, y_i, pos_x, pos_y ≤ 10⁹
0 ≤ angle < 360
All coordinates are integers
Multiple points can exist at the same coordinate

Visualization

Tap to expand

Understanding the Visualization

Setup the Scene

Position yourself at the given location with points scattered around

Calculate Angles

Convert each point's position to its polar angle relative to your position

Handle Circularity

Duplicate angles with +360° to handle the circular nature of rotation

Sliding Window

Use two pointers to find the maximum points within any viewing angle span

Add Same Location

Include points at your exact location (always visible)

Key Takeaway

🎯 Key Insight: The optimal viewing direction will always have at least one point at the edge of the field of view, so we only need to check rotations centered around existing point angles.

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 15

The optimal approach uses sliding window technique after converting points to polar angles. Key insight: duplicate angles with +360° to handle circular boundary, then find the maximum points within any angle-degree window using two pointers.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window (Optimal)	O(n log n)	O(n)	Sort angles and use sliding window to find maximum points in any angle-degree span
Brute Force (Try All Rotations)	O(n²)	O(n)	Try every possible rotation angle and count visible points

Sliding Window (Optimal) — Algorithm Steps

Separate points at same location (always visible)
Calculate and sort polar angles for remaining points
Duplicate angles by adding 360° to handle circular nature
Use two pointers to maintain a sliding window of size 'angle'
Slide window and track maximum points in any window
Add back the points at same location

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Angles

Convert all point positions to sorted polar angles

Duplicate for Circular

Add 360° to each angle to handle circular boundary

Sliding Window

Use two pointers to maintain window of size 'angle'

Track Maximum

Find window position with maximum number of points

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    double da = *(const double*)a;
    double db = *(const double*)b;
    return (da > db) - (da < db);
}

int visiblePointsCount(int** points, int pointsSize, int angle, int* location) {
    // Count points at same location
    int sameLocation = 0;
    double* angles = (double*)malloc(pointsSize * 2 * sizeof(double));
    int angleCount = 0;
    
    for (int i = 0; i < pointsSize; i++) {
        if (points[i][0] == location[0] && points[i][1] == location[1]) {
            sameLocation++;
        } else {
            // Calculate angle in degrees
            double angleDeg = atan2(points[i][1] - location[1], points[i][0] - location[0]) * 180 / M_PI;
            angles[angleCount++] = angleDeg;
        }
    }
    
    if (angleCount == 0) {
        free(angles);
        return sameLocation;
    }
    
    // Sort angles
    qsort(angles, angleCount, sizeof(double), compare);
    
    // Duplicate angles with +360 to handle circular nature
    int n = angleCount;
    for (int i = 0; i < n; i++) {
        angles[angleCount++] = angles[i] + 360;
    }
    
    // Sliding window to find maximum points within 'angle' degrees
    int maxCount = 0;
    int left = 0;
    
    for (int right = 0; right < angleCount; right++) {
        // Shrink window while it's larger than 'angle' degrees
        while (angles[right] - angles[left] > angle) {
            left++;
        }
        
        // Only count original angles (not duplicated ones)
        int count = right - left + 1;
        if (right >= n && count > n) {
            count = n;
        }
        if (count > maxCount) {
            maxCount = count;
        }
    }
    
    free(angles);
    return maxCount + sameLocation;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting angles, then O(n) for sliding window traversal

⚡ Linearithmic

Space Complexity

O(n)

Need to store angles array and duplicated angles for circular handling

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

1.2K 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

Sliding Window (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler