Max Points on a Line - Practice Coding Problems

Max Points on a Line - Problem

Given an array of points where points[i] = [x_i, y_i] represents coordinates on a 2D plane, find the maximum number of points that lie on the same straight line.

This is a classic computational geometry problem that tests your understanding of slope calculations, hash tables, and mathematical precision. You'll need to consider edge cases like vertical lines, identical points, and floating-point precision issues.

Key Challenge: Two points always form a line, but finding the maximum number of collinear points requires checking all possible line combinations efficiently.

Input & Output

example_1.py — Basic collinear points

$ Input: points = [[1,1],[2,2],[3,3]]

› Output: 3

💡 Note: All three points lie on the same line y = x, so the maximum number of collinear points is 3.

example_2.py — Mixed collinear groups

$ Input: points = [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]

› Output: 4

💡 Note: Points [1,1], [3,2], [5,3] form one line, and points [1,4], [2,3], [4,1] form another line. Both contain 3 points, but we can find 4 points on a single line.

example_3.py — Edge case with duplicates

$ Input: points = [[1,1],[1,1],[2,2]]

› Output: 3

💡 Note: Even with duplicate points at [1,1], all points are collinear on the line y = x, giving us 3 total points.

Visualization

Tap to expand

Understanding the Visualization

Choose Anchor Point

Select a reference point to calculate slopes from

Calculate All Slopes

Compute normalized slopes from anchor to every other point

Group by Slope

Points with identical slopes are collinear with the anchor

Count Maximum Group

Find the largest group plus the anchor point

Try All Anchors

Repeat process with each point as anchor to find global maximum

Key Takeaway

🎯 Key Insight: By fixing each point as an anchor and grouping others by slope, we efficiently find all collinear combinations without checking every possible line explicitly. The slope grouping method reduces complexity from O(n³) to O(n²) while handling precision issues through rational slope representation.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n points, calculate slopes to all other n points. Hash operations are O(1) average case.

⚠ Quadratic Growth

Space Complexity

O(n)

Hash table to store slope frequencies for each anchor point, maximum n-1 entries per iteration

⚡ Linearithmic Space

Constraints

1 ≤ points.length ≤ 300
points[i].length == 2
-10⁴ ≤ x_i, y_i ≤ 10⁴
All points are unique except for duplicates explicitly mentioned

Asked in

G Google 45 Apple 38 f Meta 32 ⊞ Microsoft 28 a Amazon 25

The optimal solution uses slope grouping with hash tables in O(n²) time. For each point as an anchor, calculate slopes to all other points and group them by slope - points with identical slopes are collinear. Use rational slope representation (dy/dx after GCD normalization) to avoid floating-point precision issues. Handle special cases like vertical lines and duplicate points carefully.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check every possible pair of points to form a line, then count collinear points
Slope Grouping with Hash Table (Optimal)	O(n²)	O(n)	For each point, group other points by slope and find the largest group

Brute Force (Triple Nested Loops) — Algorithm Steps

For each pair of points (i, j), form a potential line
For each remaining point k, check if it's collinear with points i and j
Use cross product or slope comparison to determine collinearity
Keep track of the maximum count found
Handle edge cases like duplicate points and vertical lines

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick First Pair

Select two points to form a potential line

Form Line

Create a line through the selected points

Check Others

Test each remaining point for collinearity

Count Points

Count total points on this line

Repeat

Try all possible pairs and find maximum

Code -

solution.c — C

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

int isCollinear(int* p1, int* p2, int* p3) {
    return (p2[1] - p1[1]) * (p3[0] - p1[0]) == (p3[1] - p1[1]) * (p2[0] - p1[0]);
}

int maxPointsOnALine(int** points, int pointsSize) {
    if (pointsSize <= 2) return pointsSize;
    
    int maxPoints = 0;
    
    for (int i = 0; i < pointsSize; i++) {
        for (int j = i + 1; j < pointsSize; j++) {
            int count = 2;
            
            for (int k = 0; k < pointsSize; k++) {
                if (k != i && k != j) {
                    if (isCollinear(points[i], points[j], points[k])) {
                        count++;
                    }
                }
            }
            
            if (count > maxPoints) {
                maxPoints = count;
            }
        }
    }
    
    return maxPoints;
}

int main() {
    int points[][2] = {{1, 1}, {2, 2}, {3, 3}};
    int* ptrs[3] = {points[0], points[1], points[2]};
    printf("%d\n", maxPointsOnALine(ptrs, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: O(n²) to pick pairs of points, O(n) to check each remaining point

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track maximum count and current calculations

✓ Linear Space

Constraints

1 ≤ points.length ≤ 300
points[i].length == 2
-10⁴ ≤ x_i, y_i ≤ 10⁴
All points are unique except for duplicates explicitly mentioned

67.5K Views

Medium Frequency

~35 min Avg. Time

2.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Triple Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler