Line Reflection

Line Reflection - Problem

Given n points on a 2D plane, find if there is such a line parallel to the y-axis that reflects the given points symmetrically.

In other words, answer whether or not if there exists a line that after reflecting all points over the given line, the original points' set is the same as the reflected ones.

Note: There can be repeated points.

Input & Output

Example 1 — Perfect Symmetry

$ 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 reflections exist in the original set.

Example 2 — No Symmetry

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

› Output: false

💡 Note: The reflection line would be at x = 0. Point (1,1) reflects to (-1,1), but (-1,1) doesn't exist. Point (-1,-1) reflects to (1,-1), but (1,-1) doesn't exist.

Example 3 — Single Point

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

› Output: true

💡 Note: A single point can always be reflected across a line through itself, so it's symmetric.

Constraints

1 ≤ points.length ≤ 10⁴
-10⁸ ≤ points[i][0], points[i][1] ≤ 10⁸

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is that if a reflection line exists, it must be at the center of all points' x-coordinates: (min_x + max_x) / 2. The optimal approach calculates this center line and uses a hash set to verify each point has its reflection in O(1) time. Time: O(n), Space: O(n)

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

Brute Force - Try All Possible Lines

⏱️ Time: O(n³) Space: O(n)

For each unique x-coordinate in the input, try using it as a potential reflection line. Check if every point has its corresponding reflection in the set.

Hash Map with Center Line Calculation

⏱️ Time: O(n) Space: O(n)

First determine the unique reflection line position using min/max x-coordinates. Then use a hash set to check if every point has its corresponding reflection.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

char** solution(char** words, int* groups, int n, int* returnSize) {
    char** result = malloc(n * sizeof(char*));
    *returnSize = 0;
    
    if (n == 0) return result;
    
    result[0] = words[0];
    *returnSize = 1;
    int lastGroup = groups[0];
    
    // Greedily select words with alternating group values
    for (int i = 1; i < n; i++) {
        if (groups[i] != lastGroup) {
            result[*returnSize] = words[i];
            (*returnSize)++;
            lastGroup = groups[i];
        }
    }
    
    return result;
}

int main() {
    char** words = malloc(100000 * sizeof(char*));
    int* groups = malloc(100000 * sizeof(int));
    int n = 0;
    
    char line[1000000];
    
    // Read words array
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, "[]\",\n ");
    while (token != NULL) {
        words[n] = malloc((strlen(token) + 1) * sizeof(char));
        strcpy(words[n], token);
        n++;
        token = strtok(NULL, "[]\",\n ");
    }
    
    // Read groups array
    fgets(line, sizeof(line), stdin);
    token = strtok(line, "[],\n ");
    int i = 0;
    while (token != NULL && i < n) {
        groups[i] = atoi(token);
        i++;
        token = strtok(NULL, "[],\n ");
    }
    
    int returnSize;
    char** result = solution(words, groups, n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(words[i]);
    }
    free(words);
    free(groups);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

456 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