Symmetric Coordinates - Practice Coding Problems

Symmetric Coordinates - Problem

Database Medium

Given a table of coordinate points, find all symmetric coordinate pairs that exist in the table.

Two coordinates (X1, Y1) and (X2, Y2) are considered symmetric if:

X1 == Y2 and X2 == Y1

From all symmetric pairs found, return only the unique coordinates where X ≤ Y, ordered by X and Y in ascending order.

Example: Points (1, 2) and (2, 1) are symmetric because the X-coordinate of the first equals the Y-coordinate of the second, and vice versa.

This problem tests your ability to identify coordinate relationships and apply filtering conditions efficiently.

Input & Output

example_1.py — Basic Symmetric Pairs

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

› Output: [[1,2],[3,4],[5,5]]

💡 Note: (1,2) and (2,1) are symmetric, (3,4) and (4,3) are symmetric, (5,5) is symmetric with itself. All satisfy X ≤ Y condition.

example_2.py — No Symmetric Pairs

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

› Output: []

💡 Note: No symmetric pairs exist - none of these coordinates have their mirror coordinates in the table.

example_3.py — Duplicate Coordinates

$ Input: coordinates = [[1,2],[2,1],[1,2],[2,1],[0,0]]

› Output: [[0,0],[1,2]]

💡 Note: Even with duplicates, we return unique coordinates. (0,0) is symmetric with itself, and (1,2)/(2,1) form a symmetric pair.

Constraints

1 ≤ coordinates.length ≤ 1000
-10⁶ ≤ X, Y ≤ 10⁶
coordinates may contain duplicate entries
Result must be sorted by X coordinate first, then Y coordinate

Visualization

Tap to expand

Understanding the Visualization

Identify Pattern

Two points (a,b) and (c,d) are symmetric if a=d and b=c

Hash Table Storage

Store each coordinate as we see it and look for its mirror

Apply Filters

Only keep unique results where X ≤ Y to avoid duplicates

Sort Results

Return coordinates ordered by X, then Y

Key Takeaway

🎯 Key Insight: Use hash table lookups to find symmetric partners in O(1) time instead of checking all pairs

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 22

The optimal approach uses a hash table in one pass to efficiently find symmetric coordinate pairs. As we process each coordinate, we check if its symmetric partner already exists in our hash set. This achieves O(n) time complexity compared to the brute force O(n²) approach, making it ideal for large datasets.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check every coordinate against every other coordinate for symmetry
One-Pass Hash Table (Optimal)	O(n)	O(n)	Build hash map and search for symmetric pairs simultaneously in one pass

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each coordinate (X1, Y1) in the table
For each coordinate, check all other coordinates (X2, Y2)
If X1 == Y2 and X2 == Y1, we found a symmetric pair
Only keep coordinates where X ≤ Y to avoid duplicates
Sort the results by X and Y in ascending order

Visualization

Tap to expand

Step-by-Step Walkthrough

Select First Coordinate

Pick coordinate (1,2) and compare against all others

Check Symmetry

Test if (1,2) and (2,1) are symmetric: 1==1? 2==2? Yes!

Apply Filter

Since 1 ≤ 2, add (1,2) to results

Continue Process

Repeat for all coordinates in the table

Code -

solution.c — C

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

typedef struct {
    int x, y;
} Coordinate;

int compare(const void *a, const void *b) {
    Coordinate *ca = (Coordinate*)a;
    Coordinate *cb = (Coordinate*)b;
    if (ca->x != cb->x) return ca->x - cb->x;
    return ca->y - cb->y;
}

int solution(Coordinate *coordinates, int n, Coordinate *result) {
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        int x1 = coordinates[i].x, y1 = coordinates[i].y;
        for (int j = 0; j < n; j++) {
            if (i != j) {
                int x2 = coordinates[j].x, y2 = coordinates[j].y;
                // Check if symmetric
                if (x1 == y2 && y1 == x2) {
                    // Only add if x <= y and not already in result
                    if (x1 <= y1) {
                        int found = 0;
                        for (int k = 0; k < count; k++) {
                            if (result[k].x == x1 && result[k].y == y1) {
                                found = 1;
                                break;
                            }
                        }
                        if (!found) {
                            result[count].x = x1;
                            result[count].y = y1;
                            count++;
                        }
                    }
                }
            }
        }
    }
    
    qsort(result, count, sizeof(Coordinate), compare);
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check every coordinate against every other coordinate

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for iteration, no additional data structures

✓ Linear Space

52.4K Views

Medium Frequency

~15 min Avg. Time

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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler