Number of Boomerangs - Practice Coding Problems

Number of Boomerangs - Problem

Number of Boomerangs

Imagine you have n distinct points scattered across a 2D plane, where each point is represented as points[i] = [xi, yi]. Your task is to find all possible boomerangs that can be formed from these points.

A boomerang is defined as a tuple of three points (i, j, k) where:
• The distance from point i to point j equals the distance from point i to point k
• Point i acts as the pivot or center of the boomerang
• The order matters - (i, j, k) and (i, k, j) are considered different boomerangs

Return the total number of boomerangs that can be formed from the given points.

Example: If points [0,0], [1,0], and [0,1] are given, point [0,0] can be the pivot with equal distances to the other two points, forming 2 boomerangs: (0,1,2) and (0,2,1).

Input & Output

example_1.py — Basic case

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

› Output: 2

💡 Note: Point [0,0] can form 2 boomerangs: (0,1,2) and (0,2,1) since distance from [0,0] to [1,0] equals distance from [0,0] to [0,1] (both are 1 unit).

example_2.py — Single point

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

› Output: 0

💡 Note: Cannot form any boomerang with only one point since we need exactly three points for a boomerang tuple.

example_3.py — Multiple equidistant points

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

› Output: 20

💡 Note: Point [0,0] has 4 other points all at distance 1 from it. This gives us 4×(4-1) = 12 boomerangs. Each of the other 4 points contributes 2×(2-1) = 2 boomerangs each, totaling 12 + 4×2 = 20.

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

Key Insight: Each group of k equidistant points creates k×(k-1) boomerang arrangementsThis is because order matters: (pivot, point1, point2) ≠ (pivot, point2, point1)

Understanding the Visualization

Choose Your Position

Pick any point as your starting position (pivot point)

Measure All Distances

Use your compass to measure distance to every other point

Group by Distance

Group points that are exactly the same distance away

Count Boomerang Patterns

For each group of k points: k×(k-1) boomerang patterns

Try Next Position

Move to next point and repeat the process

Key Takeaway

🎯 Key Insight: The hash map approach transforms an O(n³) brute force solution into an elegant O(n²) algorithm by recognizing that if k points are equidistant from a pivot, they automatically form k×(k-1) boomerangs due to the ordered nature of the tuples.

Asked in

G Google 23 a Amazon 15 ⊞ Microsoft 12 Apple 8

The optimal solution uses a hash map approach with O(n²) time complexity. For each point as pivot, we count how many points are at each distance using a hash map. If k points are equidistant from a pivot, they form k×(k-1) boomerangs since we have k choices for the first endpoint and k-1 for the second.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check every possible combination of three points to see if they form a boomerang
Hash Map Optimization (Optimal)	O(n²)	O(n)	For each pivot point, use a hash map to count points at each distance, then calculate boomerangs

Brute Force (Triple Nested Loops) — Algorithm Steps

Iterate through all points as potential pivot points (i)
For each pivot, iterate through all other points as first endpoint (j)
For each first endpoint, iterate through remaining points as second endpoint (k)
Calculate distance from pivot to both endpoints
If distances are equal, increment boomerang count

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Pivot

Choose point i as the pivot (center of potential boomerang)

First Endpoint

Choose point j as the first endpoint

Second Endpoint

Choose point k as the second endpoint

Check Distances

Calculate distance from i to j and from i to k

Count Boomerang

If distances are equal, we found a boomerang!

Code -

solution.c — C

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

int distanceSquared(int* p1, int* p2) {
    return (p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1]);
}

int numberOfBoomerangs(int** points, int pointsSize) {
    int count = 0;
    
    for (int i = 0; i < pointsSize; i++) {  // pivot point
        for (int j = 0; j < pointsSize; j++) {  // first endpoint
            if (i == j) continue;
            for (int k = 0; k < pointsSize; k++) {  // second endpoint
                if (i == k || j == k) continue;
                
                // Check if distances from pivot to both endpoints are equal
                if (distanceSquared(points[i], points[j]) == distanceSquared(points[i], points[k])) {
                    count++;
                }
            }
        }
    }
    
    return count;
}

int main() {
    // Simple input parsing for demonstration
    int n = 3;
    int** points = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        points[i] = (int*)malloc(2 * sizeof(int));
    }
    
    // Example: [[0,0],[1,0],[0,1]]
    points[0][0] = 0; points[0][1] = 0;
    points[1][0] = 1; points[1][1] = 0;
    points[2][0] = 0; points[2][1] = 1;
    
    printf("%d\n", numberOfBoomerangs(points, n));
    
    for (int i = 0; i < n; i++) {
        free(points[i]);
    }
    free(points);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops through all points, each taking O(n) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to store distances and count

✓ Linear Space

24.2K Views

Medium Frequency

~25 min Avg. Time

847 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 (Triple Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler