Detect Squares - Practice Coding Problems

Detect Squares - Problem

Design a Square Detection System

You're building a geometric analysis system that processes a stream of 2D points and can detect axis-aligned squares in real-time. Your system needs to handle two main operations:

🔹 Add Points: As new points arrive from the stream, store them in your data structure. Note: Duplicate points are allowed and should be counted as separate points.

🔹 Count Squares: Given any query point, determine how many different ways you can choose 3 points from your stored data such that these 3 points plus the query point form an axis-aligned square with positive area.

An axis-aligned square has all edges parallel to the coordinate axes, equal side lengths, and forms a perfect square shape.

Example: If you have points at (0,0), (0,1), (1,0), and (1,1), they form a unit square. Given query point (0,0), there's exactly 1 way to choose the other 3 points to complete this square.

Input & Output

basic_square.py — Python

$ Input: ds = DetectSquares()\nds.add([3, 10])\nds.add([11, 2])\nds.add([3, 2])\nds.count([11, 10]) # Query\nds.count([14, 8]) # Query\nds.add([11, 2]) # Add duplicate\nds.count([11, 10]) # Query again

› Output: 1\n0\n2

💡 Note: First query [11,10]: We can form a square using points (3,10), (11,2), (3,2) with the query point. Second query [14,8]: No valid squares can be formed. After adding duplicate (11,2), the count doubles because we now have 2 ways to choose that corner point.

no_squares.py — Python

$ Input: ds = DetectSquares()\nds.add([1, 1])\nds.add([2, 2])\nds.add([3, 3])\nds.count([1, 1])\nds.count([5, 5])

› Output: 0\n0

💡 Note: These points lie on a diagonal line and cannot form any squares. No matter which point we query, there are no valid axis-aligned squares that can be formed.

multiple_squares.py — Python

$ Input: ds = DetectSquares()\nds.add([0, 0])\nds.add([0, 1])\nds.add([1, 0])\nds.add([1, 1])\nds.add([0, 2])\nds.add([2, 0])\nds.add([2, 2])\nds.count([2, 1])

› Output: 2

💡 Note: Query point (2,1) can form squares in two ways: 1) With points (0,1), (2,0), (0,0) forming a rectangle, and 2) With points (0,1), (2,2), (0,2). Wait, let me recalculate... Actually (2,1) can form squares with: (1,0)+(2,0)+(1,1) and (1,1)+(2,2)+(1,2) but (1,2) doesn't exist. So result should be 1.

Constraints

At most 3000 calls in total will be made to add and count
point.length == 2
0 ≤ x_i, y_i ≤ 1000
Important: Duplicate points are allowed and should be treated as different points in counting

Visualization

Tap to expand

uniquely determinedThis reduces our search from O(n³) to O(n²)

Understanding the Visualization

Store Points

Keep a hash map of all points with their frequencies

Find Diagonals

For query point Q, test each stored point P as potential diagonal

Validate Square

Check if |Qx-Px| = |Qy-Py| (equal side lengths)

Calculate Corners

The other corners must be at (Qx,Py) and (Px,Qy)

Count Combinations

Multiply frequencies of all required corner points

Key Takeaway

🎯 Key Insight: By recognizing that diagonal corners uniquely determine a square, we can efficiently count squares by testing each stored point as a potential diagonal partner with our query point.

Asked in

D DoorDash 15 G Google 12 A Amazon 8 ⊞ Microsoft 6

The optimal approach uses a hash map to store point frequencies and leverages the key insight that for any two diagonal corners of an axis-aligned square, the other two corners are uniquely determined. By checking each stored point as a potential diagonal partner with our query point, we can calculate where the remaining corners must be and verify their existence in O(n) time per query.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map for Point Lookup (Optimized Brute Force)	O(n²)	O(n)	Use hash map to store points and optimize square validation by checking diagonal relationships
Brute Force (Check All Combinations)	O(n³)	O(n)	Check every possible combination of 3 points to see if they form a square with the query point

Hash Map for Point Lookup (Optimized Brute Force) — Algorithm Steps

Store points in a hash map with coordinates as keys and counts as values
For each query, iterate through all stored points as potential diagonal corners
Calculate where the other two corners of the square must be located
Check if those corners exist in our hash map and count occurrences

Visualization

Tap to expand

Step-by-Step Walkthrough

Store in HashMap

Store points with their frequencies in hash map

Find Diagonals

For query point, check each stored point as potential diagonal

Calculate Corners

If diagonal is valid, calculate the other two corner positions

Lookup & Count

Check if calculated corners exist and multiply their frequencies

Code -

solution.c — C

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

#define MAX_POINTS 1000
#define KEY_SIZE 32

typedef struct {
    char keys[MAX_POINTS][KEY_SIZE];
    int values[MAX_POINTS];
    int size;
} DetectSquares;

DetectSquares* detectSquaresCreate() {
    DetectSquares* obj = (DetectSquares*)malloc(sizeof(DetectSquares));
    obj->size = 0;
    return obj;
}

int findKey(DetectSquares* obj, const char* key) {
    for (int i = 0; i < obj->size; i++) {
        if (strcmp(obj->keys[i], key) == 0) {
            return i;
        }
    }
    return -1;
}

void detectSquaresAdd(DetectSquares* obj, int* point, int pointSize) {
    char key[KEY_SIZE];
    snprintf(key, KEY_SIZE, "%d,%d", point[0], point[1]);
    
    int index = findKey(obj, key);
    if (index >= 0) {
        obj->values[index]++;
    } else {
        strcpy(obj->keys[obj->size], key);
        obj->values[obj->size] = 1;
        obj->size++;
    }
}

int getValue(DetectSquares* obj, const char* key) {
    int index = findKey(obj, key);
    return index >= 0 ? obj->values[index] : 0;
}

int detectSquaresCount(DetectSquares* obj, int* point, int pointSize) {
    int qx = point[0], qy = point[1];
    int result = 0;
    
    for (int i = 0; i < obj->size; i++) {
        int px, py;
        sscanf(obj->keys[i], "%d,%d", &px, &py);
        int count1 = obj->values[i];
        
        if (px == qx || py == qy) continue;
        if (abs(px - qx) != abs(py - qy)) continue;
        
        char corner1[KEY_SIZE], corner2[KEY_SIZE];
        snprintf(corner1, KEY_SIZE, "%d,%d", qx, py);
        snprintf(corner2, KEY_SIZE, "%d,%d", px, qy);
        
        int count2 = getValue(obj, corner1);
        int count3 = getValue(obj, corner2);
        
        result += count1 * count2 * count3;
    }
    
    return result;
}

void detectSquaresFree(DetectSquares* obj) {
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each query, we check all stored points as potential diagonal corners, giving us O(n²) combinations to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Hash map to store point coordinates and their frequencies

⚡ Linearithmic Space

23.8K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Hash Map for Point Lookup (Optimized Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler