Number of Boomerangs

Number of Boomerangs - Problem

You are given n points in the plane that are all distinct, where points[i] = [xi, yi].

A boomerang is a tuple of points (i, j, k) such that the distance between i and j equals the distance between i and k (the order of the tuple matters).

Return the number of boomerangs.

Input & Output

Example 1 — Basic Boomerangs

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

› Output: 2

💡 Note: Two boomerangs exist: (1,0,2) and (1,2,0). From point [1,0]: distance to [0,0] = 1, distance to [2,0] = 1 (equal distances). The other points don't have equal distances to any pair of other points.

Example 2 — Square Formation

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

› Output: 2

💡 Note: Points form a diagonal line. From [2,2]: distance to [1,1] = √2, distance to [3,3] = √2. So (2,1,3) and (2,3,1) are valid boomerangs.

Example 3 — No Boomerangs

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

› Output: 0

💡 Note: Only one point exists, so no boomerangs can be formed (need at least 3 points).

Constraints

n == points.length
1 ≤ n ≤ 500
points[i].length == 2
-10⁴ ≤ x_i, y_i ≤ 10⁴
All the points are unique

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 🍎 Apple 8

The key insight is that for each point as center, we need to count how many pairs of other points are equidistant from it. Best approach uses hash map frequency counting to achieve O(n²) time instead of O(n³). For each distance with k points, we can form k*(k-1) ordered boomerangs. Time: O(n²), Space: O(n).

Common Approaches

✓ Brute Force - Check All Triplets

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

For each possible triplet (i, j, k), calculate distances from i to j and from i to k. If they're equal, increment the boomerang count.

Hash Map - Group by Distance

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

For each point as center, calculate distances to all other points and group them by distance using a hash map. For each distance with k points, we can form k*(k-1) boomerangs.

Brute Force - Check All Triplets — Algorithm Steps

Step 1: Use three nested loops to generate all possible triplets
Step 2: For each triplet, calculate distance from first point to second and third
Step 3: If distances are equal, count as a boomerang

Visualization

Tap to expand

Step-by-Step Walkthrough

Triple Nested Loops

Generate all triplets (i,j,k)

Distance Check

Calculate distances from i to j and i to k

Count Matches

If distances equal, increment boomerang count

Code -

solution.c — C

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

int solution(int** points, int pointsSize) {
    int count = 0;
    
    for (int i = 0; i < pointsSize; i++) {
        for (int j = 0; j < pointsSize; j++) {
            for (int k = 0; k < pointsSize; k++) {
                if (i != j && i != k && j != k) {
                    int distIJ = (points[i][0] - points[j][0]) * (points[i][0] - points[j][0]) + 
                                (points[i][1] - points[j][1]) * (points[i][1] - points[j][1]);
                    int distIK = (points[i][0] - points[k][0]) * (points[i][0] - points[k][0]) + 
                                (points[i][1] - points[k][1]) * (points[i][1] - points[k][1]);
                    if (distIJ == distIK) {
                        count++;
                    }
                }
            }
        }
    }
    
    return count;
}

int main() {
    char buffer[10000];
    fgets(buffer, sizeof(buffer), stdin);
    
    int points[500][2];
    int** pointPtrs = malloc(500 * sizeof(int*));
    int pointsSize = 0;
    
    char* token = strtok(buffer, "[],\n");
    while (token != NULL && pointsSize < 500) {
        if (strlen(token) > 0 && strchr(token, ' ') == NULL) {
            points[pointsSize][0] = atoi(token);
            token = strtok(NULL, "[],\n");
            if (token != NULL) {
                points[pointsSize][1] = atoi(token);
                pointPtrs[pointsSize] = points[pointsSize];
                pointsSize++;
            }
        }
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", solution(pointPtrs, pointsSize));
    free(pointPtrs);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops iterate through all possible triplets

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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 - Check All Triplets — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler