Maximum Number of Visible Points: Angle Sweep with Sliding Window

You are standing at a given location on a 2D plane. You are given an array of points and an integer angle representing your field of view in degrees. Your field of view is a sector centered on some direction you choose. Return the maximum number of points you can see. Points that overlap with your location are always visible, regardless of your angle.

This is LeetCode 1610: Maximum Number of Visible Points, and it is a beautiful combination of geometry, sorting, and sliding windows. The trick is to transform a 2D spatial problem into a 1D circular range problem.

Why this problem matters

At first glance, this looks like a pure geometry problem. You might think about rotating a cone and checking which points fall inside. That brute-force approach would be painfully slow. The real lesson here is the transformation: once you convert 2D coordinates into 1D angles, the problem reduces to "find the longest window of size angle in a sorted circular array." That is a classic sliding window problem.

This conversion pattern (reduce a harder problem to a known simpler one) shows up constantly. If you can recognize when a problem hides a sliding window or two-pointer pattern behind geometric or spatial language, you can solve a much wider class of problems.

The key insight

Every point relative to your location can be described by a single angle (its direction from you). If you compute atan2(dy, dx) for each point, you get an angle in radians. Convert to degrees and you have a list of numbers. Now the question becomes: "What is the maximum number of these angle values that fit within a window of width angle?"

Because angles wrap around (359 degrees is close to 1 degree), you cannot just sort and slide a window. You need to handle the circular boundary. The standard trick: duplicate the sorted angle array, adding 360 to each element in the copy. Now a window that wraps around 360 will appear as a contiguous range in the extended array.

Points sitting exactly at your location have no meaningful direction. You remove them from the angle list, count them separately, and add that count to the final answer.

The solution

import math

def visible_points(points: list[list[int]], angle: int, location: list[int]) -> int:
    same = 0
    angles = []
    ox, oy = location

    for x, y in points:
        if x == ox and y == oy:
            same += 1
        else:
            angles.append(math.atan2(y - oy, x - ox) * 180 / math.pi)

    angles.sort()
    n = len(angles)
    angles += [a + 360 for a in angles]

    best = 0
    left = 0
    for right in range(len(angles)):
        while angles[right] - angles[left] > angle:
            left += 1
        best = max(best, right - left + 1)

    return best + same

The first loop separates two categories of points. Points at the exact location are counted in same because they are always visible no matter which direction you face. Every other point gets its angle computed via atan2 and stored in the angles list.

After sorting, we duplicate the array by appending a + 360 for each angle a. This is the circular wrap-around trick. If your field of view spans from 350 degrees to 80 degrees, that range would be broken into two pieces in the original array. In the extended array, it appears as a single contiguous range from 350 to 440 (since 80 + 360 = 440).

The sliding window uses two pointers. The right pointer expands the window one element at a time. Whenever the window width (difference between the rightmost and leftmost angle) exceeds the allowed angle, we advance left to shrink the window. We track the maximum window size throughout.

Finally, we add same to account for the points at our exact location.

Visual walkthrough

Let's trace through the algorithm step by step. Watch how the 2D spatial problem becomes a 1D sliding window problem after the angle conversion.

The transformation from 2D coordinates to a sorted angle array is where all the difficulty lives. Once you have that sorted list and handle the circular duplication, the sliding window is the same one you have seen in dozens of other problems.

Complexity analysis

Time is O(n log n) due to sorting the angles array. The atan2 computation is O(n), and the two-pointer sliding window over the doubled array is O(n). Sorting dominates.

Space is O(n) for the angles array and its doubled copy. We store at most 2n angle values.

The building blocks

1. Coordinate-to-angle conversion with atan2

The pattern of converting 2D relative positions into angles for circular processing:

angles = []
for x, y in points:
    angles.append(math.atan2(y - oy, x - ox) * 180 / math.pi)

Any time you need to reason about directions from a fixed point, atan2 is the tool. It handles all four quadrants correctly and gives you a unique angle for each direction. You will see this in problems involving visibility, angular sorting, and sweep line algorithms. The key detail: atan2 takes (dy, dx), not (dx, dy). Swapping them gives the wrong angle.

2. Circular array duplication for wrap-around

The pattern of doubling a sorted array to handle circular ranges:

angles.sort()
angles += [a + 360 for a in angles]

When a range can wrap around the boundary (end of array connects to start), duplicating the array eliminates the special case. Instead of checking two segments separately, you check one contiguous window in the doubled array. This technique works for any circular sliding window problem, not just angles. You will see it with circular queues, rotated arrays, and scheduling problems where time wraps around midnight.

Edge cases

Before submitting, think through these scenarios:

• All points at the viewer's location: every point is always visible. same equals the array length, and the angles list is empty. The answer is just same.
• Angle is 360 or greater: every point is visible regardless of direction. The window covers the entire circle.
• Two points at the exact same angle: the sliding window counts them both. No special handling needed.
• Only one point (not at location): the answer is 1 + same. The window always captures at least one angle.
• Points on the boundary of the viewing angle: the problem states points on the edge of the field of view count as visible. Use >= in your comparisons, which the while angles[right] - angles[left] > angle formulation handles correctly (it keeps points exactly at distance angle inside the window).
• Negative coordinates: atan2 handles negative dx and dy correctly. No normalization needed.

From understanding to recall

You now know the three-part strategy: convert coordinates to angles with atan2, handle circular wrap-around by duplicating the sorted array, and slide a window to find the maximum count. The logic makes sense when you read it. But reproducing it under pressure is where most people stumble.

The details that trip you up are small but critical. Do you use atan2(dy, dx) or atan2(dx, dy)? Do you add 360 or 2*pi? Do you use > or >= in the window condition? Do you remember to count same-location points separately? These are not conceptual misunderstandings. They are recall gaps.

Spaced repetition is how you close them. You practice the angle conversion, the array duplication, and the sliding window template from memory at increasing intervals. After a few rounds, the pattern is automatic. You see "maximum points within an angle" and the full approach flows out without hesitation.

Related posts

• Minimum Window Substring - The classic sliding window pattern for finding the smallest window that satisfies a condition
• Longest Substring Without Repeating Characters - Another sliding window problem that uses two pointers to track a valid range
• Sort Colors - Sorting techniques and partitioning that build the foundation for array manipulation

CodeBricks breaks Maximum Number of Visible Points into its angle conversion and circular sliding window building blocks, then drills them independently with spaced repetition. You type each piece from scratch until the pattern is automatic. When a geometry-meets-sliding-window problem shows up in your interview, you do not think about it. You just write it.