Line Reflection - Practice Coding Problems

Line Reflection - Problem

Line Reflection is a fascinating geometric problem that tests your understanding of symmetry and coordinate geometry.

You're given n points on a 2D plane, and your task is to determine if there exists a vertical line (parallel to the y-axis) that acts as a mirror, such that when you reflect all points across this line, you get back the exact same set of points.

Think of it as placing a mirror vertically on the coordinate plane - if the reflection of your points creates the same pattern, then such a line exists! The key insight is that this line, if it exists, must pass through the center of all points' x-coordinates.

Goal: Return true if such a reflection line exists, false otherwise.
Input: Array of points [[x₁,y₁], [x₂,y₂], ..., [xₙ,yₙ]]
Output: Boolean indicating if reflection line exists

Input & Output

example_1.py — Basic Reflection

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

› Output: true

💡 Note: The reflection line is at x = 0. Point (1,1) reflects to (-1,1) and vice versa. Both reflected points exist in the original set.

example_2.py — No Reflection Possible

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

› Output: false

💡 Note: If we try the line x = 0, point (1,1) would reflect to (-1,1), but (-1,1) doesn't exist in the original set. The point (-1,-1) would reflect to (1,-1), which also doesn't exist.

example_3.py — Multiple Points Same Line

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

› Output: false

💡 Note: For symmetry around any line, we need an even number of points or a center point. The potential line would be at x = 1.5, but point (0,0) would reflect to (3,0) and (1,0) would reflect to (2,0). Since (2,0) doesn't exist, no reflection line is possible.

Visualization

Tap to expand

Understanding the Visualization

Find Extremes

Identify the leftmost and rightmost points to determine where the mirror should be placed

Calculate Center

The mirror line must be at the exact midpoint: (min_x + max_x) / 2

Verify Reflections

Check that every point has its mirror image in the original set

Key Takeaway

🎯 Key Insight: The reflection line position is uniquely determined by the extreme points - there's only one possible line to check, making this problem efficiently solvable in O(n) time!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to build set and find min/max, plus one verification pass

✓ Linear Growth

Space Complexity

O(n)

Hash set stores all n points for constant-time lookup

⚡ Linearithmic Space

Constraints

1 ≤ points.length ≤ 2 × 10⁴
points[i].length == 2
-10⁸ ≤ points[i][0], points[i][1] ≤ 10⁸
There can be repeated points

Asked in

G Google 12 f Facebook 8 a Amazon 6 ⊞ Microsoft 4

The optimal solution uses a one-pass hash table approach with O(n) time complexity. The key insight is that any reflection line must be at the midpoint between the leftmost and rightmost points. We build a hash set while finding min/max x-coordinates, then verify that every point has its symmetric counterpart across the calculated reflection line.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Possible Lines)	O(n²)	O(n)	Try every possible vertical line position and check if reflection works
One-Pass Hash Table (Optimal)	O(n)	O(n)	Calculate reflection line and verify reflections simultaneously in one pass
Two Pointers (Sorted Array)	O(n log n)	O(n)	Sort points by x-coordinate and use two pointers to verify symmetry
Two-Pass Hash Table	O(n)	O(n)	Find the reflection line position first, then verify all reflections exist

Brute Force (Try All Possible Lines) — Algorithm Steps

Collect all unique x-coordinates as potential reflection line positions
For each potential line position, calculate the reflection of every point
Check if all reflected points exist in the original set
Return true if any line position works

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Candidates

Collect all unique x-coordinates as potential reflection lines

Test Each Line

For each candidate line, calculate reflections of all points

Verify Reflections

Check if all reflected points exist in original set

Code -

solution.c — C

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

bool isReflected(int** points, int pointsSize, int* pointsColSize) {
    if (pointsSize <= 1) return true;
    
    // For simplicity, using a basic O(n²) approach
    for (int i = 0; i < pointsSize; i++) {
        int lineX = points[i][0];
        bool isValid = true;
        
        for (int j = 0; j < pointsSize; j++) {
            int reflectedX = 2 * lineX - points[j][0];
            bool found = false;
            
            // Check if reflected point exists
            for (int k = 0; k < pointsSize; k++) {
                if (points[k][0] == reflectedX && points[k][1] == points[j][1]) {
                    found = true;
                    break;
                }
            }
            
            if (!found) {
                isValid = false;
                break;
            }
        }
        
        if (isValid) return true;
    }
    
    return false;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n potential line positions, we check n points for their reflections

⚠ Quadratic Growth

Space Complexity

O(n)

Need to store the original points in a set for O(1) lookup

⚡ Linearithmic Space

Constraints

1 ≤ points.length ≤ 2 × 10⁴
points[i].length == 2
-10⁸ ≤ points[i][0], points[i][1] ≤ 10⁸
There can be repeated points

23.4K Views

Medium Frequency

~18 min Avg. Time

892 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 (Try All Possible Lines) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler