### Analytical problem

This is a an analytical problem and it may be best to solve it first before coding to have an idea how best to structure your code.

If I understand you correctly:

- each disc has **radius one**, 
- the square is of **dimensions**:
$$ \sqrt{n} \times \sqrt{n} $$
- discs are placed sequentially at random and must cover the entire square.

If you assume, for simplicity, that the treatment of discs placed near the perimeter is to repeat/mirror rather than to truncate, then the probability that any point **z=(x,y)** in the square is covered by a single disc is the area of the disc divided by the area of the square:

$$
P(z \in Disc) = 1 - P(z \notin Disc) = \frac{\pi}{n}
$$

Adding discs to reach a total of *m* discs independently and randomly means that,

$$
P(z \in \cup Discs) = 1 - P(z \notin \cup Discs) = 1 - \left ( P(z \notin Disc_1) ... P(z \notin Disc_m) \right ) = 1 - (1-\frac{\pi}{n})^m
$$

This is a stochastic problem. Technically you could keep adding discs and might **never** cover the square but that is unlikely. If you estimated to a 99.99% likelihood that the square was covered, i.e. all points z are in the union of the discs, you can express the expected number of required discs relative to the dimension, *n*:

$$
m = \frac{ln(0.0001)}{ln(1-\frac{\pi}{n})}
$$

[![enter image description here][1]][1]

### Structuring code

I will ignore the disc chaining becuase that is a second task with not dissimilar concerns as here.

What is the optimal solution to ensure that the square is covered given some discs?

a) Don't exhaustively search every point every time you add a sphere. Once a point is covered it will be covered indefinitely. You do not need to check that point again.

b) To achieve the same 99.99% probability of coverage you need to create 10,000 gridpoints, i.e. 100 x 100.

c) Once you have discovered just one point that is not covered you need to add a disc and keep adding until that exact single point is covered, Once it is move on to check the next point.

d) I would optimise the stepping to the next point by doing two things. Firsly I would start in the top left corner and traverse north easterly and south westerly. Secondly when I stepped to a new point I would run a fast check that the same disc that covered the preceding point did not also cover that new point, becuase it is likely that a disc close by will cover multiple points. Once you find an uncovered point keep adding discs until it is covered and then move on.

This will most likely take a fraction of the time than it is currently taking for your code to run.



 [1]: https://i.sstatic.net/4aVWFXSL.png