Given the radius and the position of the center of a circle, implement the function randPoint which generates a uniform random point inside the circle.

Implement the Solution class:


	Solution(double radius, double x_center, double y_center) initializes the object with the radius of the circle radius and the position of the center (x_center, y_center).
	randPoint() returns a random point inside the circle. A point on the circumference of the circle is considered to be in the circle. The answer is returned as an array [x, y].


&nbsp;
Example 1:

Input
["Solution", "randPoint", "randPoint", "randPoint"]
[[1.0, 0.0, 0.0], [], [], []]
Output
[null, [-0.02493, -0.38077], [0.82314, 0.38945], [0.36572, 0.17248]]

Explanation
Solution solution = new Solution(1.0, 0.0, 0.0);
solution.randPoint(); // return [-0.02493, -0.38077]
solution.randPoint(); // return [0.82314, 0.38945]
solution.randPoint(); // return [0.36572, 0.17248]


&nbsp;
Constraints:


	0 &lt;&nbsp;radius &lt;= 108
	-107 &lt;= x_center, y_center &lt;= 107
	At most 3 * 104 calls will be made to randPoint.


class Solution:

    def __init__(self, radius: float, x_center: float, y_center: float):
        self.rad = radius
        self.xc = x_center
        self.yc = y_center

    def randPoint(self) -> List[float]:
        while True:
            xg=self.xc+random.uniform(-1, 1)*self.rad*2
            yg=self.yc+random.uniform(-1, 1)*self.rad*2
            if (xg-self.xc)**2 + (yg-self.yc)**2 <= self.rad**2:
                return [xg, yg]


# Your Solution object will be instantiated and called as such:
# obj = Solution(radius, x_center, y_center)
# param_1 = obj.randPoint()
class Solution {
    double radius;
    double x_center;
    double y_center;
    Random r=new Random();
    public Solution(double radius, double x_center, double y_center) {
        this.radius=radius;
        this.x_center=x_center;
        this.y_center=y_center;
    }
    
    public double[] randPoint() {
        double angle=r.nextDouble(Math.PI*2);
		//For probability is inversely proportional to radius, we use sqrt of random number.
        double rad=Math.sqrt(r.nextDouble())*radius;
        double[] ret=new double[2];
        ret[0]=rad*Math.cos(angle)+x_center;
        ret[1]=rad*Math.sin(angle)+y_center;
        return ret;
    }
}
class Solution {
public:
    double r,x,y;
    Solution(double radius, double x_center, double y_center) {
        r = radius;
        x = x_center;
        y = y_center;
    }
    
    vector<double> randPoint() {
        double x_r = ((double)rand()/RAND_MAX * (2*r)) + (x-r);
        double y_r = ((double)rand()/RAND_MAX * (2*r)) + (y-r);
        
        while(solve(x_r,y_r,x,y)>=r*r)
        {
            x_r = ((double)rand()/RAND_MAX * (2*r)) + (x-r);
            y_r = ((double)rand()/RAND_MAX * (2*r)) + (y-r);
        }
        
        return {x_r,y_r};
    }
    
    double solve(double x_r,double y_r,double x,double y)
    {
        return (x-x_r)*(x-x_r) + (y-y_r)*(y-y_r);
    }
};
/**
 * @param {number} radius
 * @param {number} x_center
 * @param {number} y_center
 */
var Solution = function(radius, x_center, y_center) {
  this.radius = radius;
  this.x_center = x_center;
  this.y_center = y_center;
};

/**
 * @return {number[]}
 */
Solution.prototype.randPoint = function() {
  const randomX = randRange(this.x_center + this.radius, this.x_center - this.radius);
  const randomY = randRange(this.y_center + this.radius, this.y_center - this.radius);
  
  const distanceInSquares = Math.pow(randomX - this.x_center, 2) + Math.pow(randomY - this.y_center, 2);
  const isOutOfTheCircle = distanceInSquares > Math.pow(this.radius, 2);
  
  if (isOutOfTheCircle)) {
    return this.randPoint();
  }

  return [randomX, randomY];
};

/** 
 * Your Solution object will be instantiated and called as such:
 * var obj = new Solution(radius, x_center, y_center)
 * var param_1 = obj.randPoint()
 */

function randRange(maximum, minimum) {
  return Math.random() * (maximum - minimum) + minimum;
}
Generate Random Point in a Circle