Valid Square - Practice Coding Problems

Valid Square - Problem

Math Geometry Medium

Imagine you're a quality inspector at a precision manufacturing company that creates square components. You're given the coordinates of four corner points in 2D space, but they're not in any particular order. Your job is to determine whether these points actually form a valid square.

A valid square must satisfy these geometric properties:

Four equal sides with positive length
Four equal angles (90-degree angles)
All corners are distinct points

Input: Four points p1, p2, p3, p4 where each point is represented as [x, y] coordinates

Output: Return true if the four points construct a perfect square, false otherwise

Challenge: The points are given in random order, so you need to figure out which points are adjacent and which are diagonally opposite!

Input & Output

example_1.py — Valid Square

$ Input: p1 = [0,0], p2 = [1,1], p3 = [1,0], p4 = [0,1]

› Output: true

💡 Note: These four points form a unit square. All sides have length 1, and both diagonals have length √2. The distance pattern [1,1,1,1,2,2] confirms it's a square.

example_2.py — Invalid Rectangle

$ Input: p1 = [0,0], p2 = [1,1], p3 = [1,0], p4 = [0,12]

› Output: false

💡 Note: These points form a rectangle, not a square. The sides have different lengths, so it fails the equal sides requirement.

example_3.py — Duplicate Points

$ Input: p1 = [1,0], p2 = [1,0], p3 = [0,1], p4 = [0,0]

› Output: false

💡 Note: Two points are identical, which means we don't have 4 distinct corners. A valid square requires 4 unique points.

Visualization

Tap to expand

Understanding the Visualization

Measure All Distances

Calculate the 6 distances between every pair of points

Sort and Group

Sort distances to identify patterns - squares have 4 equal short distances and 2 equal long distances

Apply Pythagorean Check

Verify that diagonal length equals √2 times the side length

Key Takeaway

🎯 Key Insight: A square has exactly 4 equal sides and 2 equal diagonals, with diagonal² = 2 × side²

Time & Space Complexity

Time Complexity

⏱️

O(1)

Always calculate exactly 6 distances regardless of input

✓ Linear Growth

Space Complexity

O(1)

Only store the 6 distances and a few variables

✓ Linear Space

Constraints

p1.length == p2.length == p3.length == p4.length == 2
-10⁴ <= xi, yi <= 10⁴
All coordinates are integers
Edge case: Points may be given in any order

Asked in

G Google 28 a Amazon 22 ⊞ Microsoft 18 Apple 12

The optimal approach uses geometric distance analysis. Calculate all 6 pairwise distances, sort them, and verify the pattern matches a square: 4 equal sides and 2 equal diagonals where diagonal² = 2 × side². This runs in O(1) time since we always process exactly 4 points.

Common Approaches

Approach	Time	Space	Notes
✓ Distance Analysis (Geometric Validation)	O(1)	O(1)	Calculate all pairwise distances and verify square properties

Distance Analysis (Geometric Validation) — Algorithm Steps

Calculate all 6 pairwise distances between the 4 points
Sort the distances to group equal lengths together
Verify we have exactly 4 equal shorter distances (sides)
Verify we have exactly 2 equal longer distances (diagonals)
Confirm that diagonal² = 2 × side² (Pythagorean theorem)

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Distances

Compute all 6 pairwise distances between the 4 points

Sort Distances

Sort distances to group equal lengths together

Validate Pattern

Check if pattern matches square: 4 equal sides, 2 equal diagonals

Code -

solution.c — C

bool validSquare(int** points, int pointsSize, int* pointsColSize) {
    int distances[6];
    int idx = 0;
    
    // Calculate all 6 pairwise distances
    for (int i = 0; i < 4; i++) {
        for (int j = i + 1; j < 4; j++) {
            int dist = (points[i][0] - points[j][0]) * (points[i][0] - points[j][0]) +
                      (points[i][1] - points[j][1]) * (points[i][1] - points[j][1]);
            if (dist == 0) return false; // Points are the same
            distances[idx++] = dist;
        }
    }
    
    // Sort distances
    for (int i = 0; i < 5; i++) {
        for (int j = i + 1; j < 6; j++) {
            if (distances[i] > distances[j]) {
                int temp = distances[i];
                distances[i] = distances[j];
                distances[j] = temp;
            }
        }
    }
    
    // For a square: 4 equal sides, 2 equal diagonals
    return distances[0] == distances[1] && distances[1] == distances[2] &&
           distances[2] == distances[3] && distances[4] == distances[5] &&
           distances[4] == 2 * distances[0];
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Always calculate exactly 6 distances regardless of input

✓ Linear Growth

Space Complexity

O(1)

Only store the 6 distances and a few variables

✓ Linear Space

Constraints

p1.length == p2.length == p3.length == p4.length == 2
-10⁴ <= xi, yi <= 10⁴
All coordinates are integers
Edge case: Points may be given in any order

26.8K Views

Medium Frequency

~15 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

Distance Analysis (Geometric Validation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler