Codestin Search App

Generate Random Point in a Circle - Problem

Imagine you're creating a game where players need to click random locations inside a circular target. You need to ensure these points are uniformly distributed across the entire circle area - not clustered toward the center!

Given a circle defined by its radius and center coordinates (x_center, y_center), your task is to implement a system that generates random points inside this circle with perfect uniform distribution.

Challenge: Simply using random radius and angle won't work - this creates more points near the center because inner rings have less area than outer rings!

Your Task:

Implement Solution(radius, x_center, y_center) constructor
Implement randPoint() that returns [x, y] coordinates
Points on the circumference are considered inside the circle
Ensure uniform distribution across the entire circle area

Input & Output

example_1.py — Basic Circle

$ Input: Solution(1.0, 0.0, 0.0)\nrandPoint() called multiple times

› Output: Possible outputs: [-0.123, 0.456], [0.789, -0.234], [0.0, 0.999]

💡 Note: For a unit circle centered at origin, all returned points should satisfy x² + y² ≤ 1.0

example_2.py — Offset Center

$ Input: Solution(2.0, 3.0, 4.0)\nrandPoint() called multiple times

› Output: Possible outputs: [4.567, 5.123], [1.234, 2.789], [3.0, 6.0]

💡 Note: For radius 2 centered at (3,4), points should satisfy (x-3)² + (y-4)² ≤ 4

example_3.py — Edge Case Small Radius

$ Input: Solution(0.01, 10.0, 10.0)\nrandPoint() called multiple times

› Output: Possible outputs: [10.005, 9.997], [9.999, 10.008], [10.001, 9.995]

💡 Note: Even with very small radius, points should be uniformly distributed within the tiny circle

Constraints

0 < radius ≤ 10⁸
-10⁷ ≤ x_center, y_center ≤ 10⁷
At most 3 × 10⁴ calls will be made to randPoint
Points on the circumference are considered inside the circle

Visualization

Tap to expand

Understanding the Visualization

The Problem

Simple random radius creates more points near center (smaller rings have less area)

The Solution

Square root transformation: r = R√(random) compensates for area differences

Perfect Distribution

Every equal-sized region now has equal probability of containing a point

Key Takeaway

🎯 Key Insight: Area scales with r², so radius must scale with √(random) for uniform distribution!

Asked in

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

The optimal solution uses polar coordinates with square root transformation to achieve uniform distribution. The key insight is that area grows quadratically with radius, so using r = radius × √(random) compensates for this and ensures equal probability for equal areas. This gives O(1) guaranteed performance compared to rejection sampling's variable runtime.

Common Approaches

Approach	Time	Space	Notes
✓ Rejection Sampling (Square Method)	O(1) average	O(1)	Generate random points in bounding square, reject those outside circle
Polar Coordinates with Square Root (Optimal)	O(1)	O(1)	Use polar coordinates with √(random) for radius to ensure uniform area distribution

Rejection Sampling (Square Method) — Algorithm Steps

Generate random point (x, y) in square [-radius, radius] × [-radius, radius]
Check if point is inside circle: (x² + y² ≤ radius²)
If inside, translate to actual center and return
If outside, repeat the process

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Square Points

Create random points in the bounding square

Test Distance

Check if each point is within radius from center

Accept or Reject

Keep points inside circle, discard others

Code -

solution.c — C

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

typedef struct {
    double radius;
    double x_center;
    double y_center;
} Solution;

Solution* solutionCreate(double radius, double x_center, double y_center) {
    Solution* obj = (Solution*)malloc(sizeof(Solution));
    obj->radius = radius;
    obj->x_center = x_center;
    obj->y_center = y_center;
    srand(time(NULL));
    return obj;
}

double* solutionRandPoint(Solution* obj, int* returnSize) {
    *returnSize = 2;
    double* result = (double*)malloc(2 * sizeof(double));
    
    while (1) {
        double x = ((double)rand() / RAND_MAX * 2 - 1) * obj->radius;
        double y = ((double)rand() / RAND_MAX * 2 - 1) * obj->radius;
        
        if (x * x + y * y <= obj->radius * obj->radius) {
            result[0] = obj->x_center + x;
            result[1] = obj->y_center + y;
            return result;
        }
    }
}

Time & Space Complexity

Time Complexity

⏱️

O(1) average

Expected 4/π ≈ 1.27 iterations on average, but worst case is unbounded

✓ Linear Growth

Space Complexity

O(1)

Only stores the circle parameters and temporary variables

✓ Linear Space

89.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

Rejection Sampling (Square Method) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler