Find N random points within a Circle

0 0 5 minutes read

Given four integers N, R, X, and Y such that it represents a circle of radius R with [X, Y] as coordinates of the center. The task is to find N random points inside or on the circle.
Examples:

Input: R = 12, X = 3, Y = 3, N = 5
Output: (7.05, -3.36) (5.21, -7.49) (7.53, 0.19) (-2.37, 12.05) (1.45, 11.80)
Input: R = 5, X = 1, Y = 1, N = 3
Output: (4.75, 1.03) (2.57, 5.21) (-1.98, -0.76)

Approach: To find a random point in or on a circle we need two components, an angle(theta) and distance(D) from the center. After that Now, the point (x_i, y_i) can be expressed as:

x_i = X + D * cos(theta)
y_i = Y + D * sin(theta)

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
#define PI 3.141592653589
 
// Return a random double between 0 & 1
double uniform()
{
    return (double)rand() / RAND_MAX;
}
 
// Function to find the N random points on
// the given circle
vector<pair<double, double> > randPoint(
    int r, int x, int y, int n)
{
    // Result vector
    vector<pair<double, double> > res;
 
    for (int i = 0; i < n; i++) {
 
        // Get Angle in radians
        double theta = 2 * PI * uniform();
 
        // Get length from center
        double len = sqrt(uniform()) * r;
 
        // Add point to results.
        res.push_back({ x + len * cos(theta),
                        y + len * sin(theta) });
    }
 
    // Return the N points
    return res;
}
 
// Function to display the content of
// the vector A
void printVector(
    vector<pair<double, double> > A)
{
 
    // Iterate over A
    for (pair<double, double> P : A) {
 
        // Print the N random points stored
        printf("(%.2lf, %.2lf)\n",
               P.first, P.second);
    }
}
 
// Driver Code
int main()
{
    // Given dimensions
    int R = 12;
    int X = 3;
    int Y = 3;
    int N = 5;
 
    // Function Call
    printVector(randPoint(R, X, Y, N));
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
     
static final double PI = 3.141592653589;
static class pair 
{
    double first, second;
 
    public pair(double first,
                double second)
    {
        super();
        this.first = first;
        this.second = second;
    }
}
 
// Return a random double between 0 & 1
static double uniform(){return Math.random();}
 
// Function to find the N random points on
// the given circle
static Vector<pair> randPoint(int r, int x, 
                              int y, int n)
{
     
    // Result vector
    Vector<pair> res = new Vector<pair>();
 
    for(int i = 0; i < n; i++)
    {
         
        // Get Angle in radians
        double theta = 2 * PI * uniform();
 
        // Get length from center
        double len = Math.sqrt(uniform()) * r;
 
        // Add point to results.
        res.add(new pair(x + len * Math.cos(theta),
                         y + len * Math.sin(theta)));
    }
     
    // Return the N points
    return res;
}
 
// Function to display the content of
// the vector A
static void printVector(Vector<pair> A)
{
 
    // Iterate over A
    for(pair P : A)
    {
         
        // Print the N random points stored
        System.out.printf("(%.2f, %.2f)\n", 
                          P.first, P.second);
    }
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Given dimensions
    int R = 12;
    int X = 3;
    int Y = 3;
    int N = 5;
 
    // Function call
    printVector(randPoint(R, X, Y, N));
}
}
 
// This code is contributed by Rajput-Ji

Python3

# Python program for the above approach
import math
import random
PI = 3.141592653589;
 
class pair:
 
    def __init__(self, first, second):
        self.first = first;
        self.second = second;
 
# Return a random between 0 & 1
def uniform():
    return random.random();
 
# Function to find the N random points on
# the given circle
def randPoint(r, x, y, n):
   
    # Result vector
    res = list();
 
    for i in range(n):
        # Get Angle in radians
        theta = 2 * PI * uniform();
 
        # Get length from center
        len = math.sqrt(uniform()) * r;
 
        # Add point to results.
        res.append(pair((x + len * math.cos(theta)), (y + len * math.sin(theta))));
 
    # Return the N points
    return res;
 
# Function to display the content of
# the vector A
def printVector(A):
 
    # Iterate over A
    for P in A:
        # Print the N random points stored
        print("({0:.2f}".format(P.first),", ","{0:.2f})".format(P.second));
 
# Driver Code
if __name__ == '__main__':
    # Given dimensions
    R = 12;
    X = 3;
    Y = 3;
    N = 5;
 
    # Function call
    printVector(randPoint(R, X, Y, N));
 
# This code is contributed by 29AjayKumar

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG
{
     
static readonly double PI = 3.141592653589;
class pair 
{
    public double first, second;
 
    public pair(double first,
                double second)
    {
        this.first = first;
        this.second = second;
    }
}
 
// Return a random double between 0 & 1
static double uniform()
{
    return new Random().NextDouble();
}
 
// Function to find the N random points on
// the given circle
static List<pair> randPoint(int r, int x, 
                              int y, int n)
{
     
    // Result vector
    List<pair> res = new List<pair>();
    for(int i = 0; i < n; i++)
    {
         
        // Get Angle in radians
        double theta = 2 * PI * uniform();
 
        // Get length from center
        double len = Math.Sqrt(uniform()) * r;
 
        // Add point to results.
        res.Add(new pair(x + len * Math.Cos(theta),
                         y + len * Math.Sin(theta)));
    }
     
    // Return the N points
    return res;
}
 
// Function to display the content of
// the vector A
static void printList(List<pair> A)
{
 
    // Iterate over A
    foreach(pair P in A)
    {
         
        // Print the N random points stored
        Console.Write("({0:F2}, {1:F2})\n", 
                          P.first, P.second);
    }
}
 
// Driver Code
public static void Main(String[] args)
{
     
    // Given dimensions
    int R = 12;
    int X = 3;
    int Y = 3;
    int N = 5;
 
    // Function call
    printList(randPoint(R, X, Y, N));
}
}
 
// This code is contributed by 29AjayKumar

Javascript

// JavaScript program for the above approach
 
// Return a random double between 0 & 1
function uniform()
{
    return Math.random();
}
 
// Function to find the N random points on
// the given circle
function randPoint(r, x, y, n)
{
    // Result vector
    let res = new Array();
 
    for (let i = 0; i < n; i++) {
 
        // Get Angle in radians
        let theta = 2 * Math.PI * uniform();
 
        // Get length from center
        let len = Math.sqrt(uniform()) * r;
 
        // Add point to results.
        res.push([x + len * Math.cos(theta), y + len * Math.sin(theta)]);
    }
 
    // Return the N points
    return res;
}
 
// Function to display the content of
// the vector A
function printVector(A)
{
    // Iterate over A
    for (let i = 0; i < A.length; i++) {       
        // Print the N random points stored
        console.log("(" + A[i][0].toFixed(2) + ", " + A[i][1].toFixed(2) + ")");
    }
}
 
// Driver Code
// Given dimensions
let R = 12;
let X = 3;
let Y = 3;
let N = 5;
 
// Function Call
printVector(randPoint(R, X, Y, N));
 
// The code is contributed by gautam goel (gautamgoel962)

Output:

(7.05, -3.36)
(5.21, -7.49)
(7.53, 0.19)
(-2.37, 12.05)
(1.45, 11.80)

Time Complexity: O(N)
Space Complexity: O(N)

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 zambiatek!