Rain droplets falling on a table Suppose you have a circular table of radius $R$. This table has been left outside, and it begins to rain at a constant rate of one droplet per second. The drops, which can be considered points as they fall, can only land in such a way such that they impact the surface of the table. Once they strike the table, they form a puddle of radius $r$, centered at their point of impact. What is the expected number of droplets it takes to cover the table in water?
The answer should be left in terms of $R$ and $r$. However, if you can simulate this, while changing both $r$ and $R$ so that some regression might be applied to find the approximate relation, that would be nice as well. I'd really like some intuition as to how the two are related. 
I have tried decomposing the problem by considering only the 1-dimensional case with line segments, but even its solution has eluded me. A potential starting point could be the discrete case of marbles falling into buckets. 
The following edit was suggested by Jbeuh: 
A more formal restatement of the problem :
Consider a sequence $X_1,\ldots,X_n$ of independent random variables following a uniform distribution on a disk $D$ of radius $R$. For each $i$, let $C_i$ be the disk centered at $X_i$ with radius $r$. Let $Y$ be the first $i$ such that the disks $C_1,\ldots,C_i$ forms a cover of $D$. What is the expected value of $Y$?
 A: For any covering of the target region with shapes of diameter $\le r$, if one droplet center lies within each shape, this is sufficient to cover the entire region with droplets.  This can be used to calculate an upper bound on the expected time to cover the table.  Note that this upper bound will be tighter when the number of shapes is smaller; i.e., we want the area of each shape to be as large as possible.  Suppose the covering uses regular hexagons of diameter $r$: these have area $3r^2\sqrt{3}/8$, so there will be about
$$
N_{\rm hex} = \frac{8\pi}{3\sqrt{3}}\left(\frac{R}{r}\right)^2
$$
of them.  The coupon collector's problem then states that the expected time to hit all the hexagons is $E[T_{\rm hex}] \sim N_{\rm hex}\ln N_{\rm hex}$.
On the other hand, for any packing of the target region with disks of radius $r$, it is necessary for at least one droplet center to fall within each disk in order for the target region to be covered (in particular, the disk centers cannot be covered otherwise).  This can be used to provide a lower bound on the expected time.  Here we again use a hexagonal packing, which covers a fraction $\pi/\sqrt{12}$ of the table's surface, but now the hexagon area is $2r^2\sqrt{3}$.  The number of disks is then
$$
N_{\rm disc}=\frac{\pi}{2\sqrt{3}}\left(\frac{R}{r}\right)^2=\frac{3}{16}N_{\rm hex}.
$$
The coupon collector's problem in this case states that the expected time to hit all the disks is $E[T_{\rm disc}] \sim \frac{\sqrt{12}}{\pi}N_{\rm disc}\ln N_{\rm disc}=\left(\frac{R}{r}\right)^{2}\ln N_{\rm disc}$.  Note the extra factor of $\sqrt{12}/\pi$, which comes from the fact that each droplet only "collects a coupon" with probability $\pi/\sqrt{12}$.
Putting these bounds together, we have that the expected time to cover the table satisfies
$$
2 \mu^2 \ln \mu + O(\mu^2) = E[T_{\rm disc}] \le E[T] \le E[T_{\rm hex}] = \frac{16\pi}{3\sqrt{3}} \mu^2 \ln \mu + O(\mu^2)
$$
for $\mu \equiv (R/r) \gg 1$.  In particular, the expected time is proven to be $\Theta(\mu^2 \ln \mu)$, with a multiplicative factor bounded between $2$ and about $9.68$.
A: Allow me to make some discretization approximations to a circle. Define a circle of radius $r$ at location $\bf x$ as the set of all points $\bf y$ on a lattice in $\mathbb{Z}_d$ where $\|{\bf x}-{\bf y}\|_2<r$. This isn't to bad when $r \gg 1$, shown below is a 100 radius "circle":

The approximation gets worse when $r<10$, so we will limit all droplets to this size. To code up a simple Monte Carlo example we make a square area $A$ whose length is $2R + 2r$, and put a circular table in the center of radius $R$ with a positive mask. Choose points in $A$ and keep them if they are in within the radius $R$. For each selected point, subtract a circular mask of radius $r$. Continue until the circular table is empty and count the drops needed. An example of this in motion looks like:

A time-series of the log of the area remaining for an individual run:

I ran 10 trials for $r \in 10..R-1$ and plotted the mean with the std dev as the error bar. 

I'm at a loss to describe the function - the best fit I could come up with (which really is not fit at all) was $c \exp{(-17.9 (r/R)^{-1.6})}$. At the very least, I can say that it drops faster than an exponential.
For posterity and completeness, the code I wrote is below. Note that you can generalize to $d$ dimensions!
from numpy import *

def circle(radius, dimension):
    A = zeros((2*radius+1,)*dimension)
    for idx in ndindex(A.shape):
        coord = array(idx) - radius # recenter
        r     = dot(coord, coord)
        A[idx] = r
    B = zeros(A.shape,dtype=bool)
    B[A<radius**2] = True
    return B

def spot_on_table(dimension):
    table_r_squared = table_r ** 2
    r2 = table_r_squared+1
    max_dim = 2*table_r
    while r2 > table_r_squared:
        pt = random.randint(-max_dim,max_dim,dimension)
        r2  = dot(pt,pt)
    return pt

def raindrop(table, droplet, loc, add=False):
    r = droplet.shape[0]/2
    center = array(table.shape[0])/2
    idx = [slice(center-r+x, center+r+1+x) for x in loc]
    idx = tuple(idx)

    if add: table[idx] += droplet
    else  : table[idx] *= ~droplet

def raindrop_question(dimension, droplet_r, table_r):
    random.seed()
    buff = droplet_r

    # Create the table
    table = zeros((2*table_r+1+2*buff,)*dimension)
    raindrop(table,circle(table_r,dimension), zeros(dimension), add=True)

    # Let it rain!
    counter = 0
    while table.any():
        raindrop(table,circle(droplet_r,dimension), spot_on_table(dimension))
        counter += 1

    return (dimension, droplet_r, table_r), counter

def CB(sol):
    print sol

import multiprocessing, itertools

dimension = 2
table_r   = 100
droplet_r = arange(10,table_r)

P = multiprocessing.Pool(16)

for r in droplet_r:
    for n in xrange(10):
        sol = P.apply_async(raindrop_question, (dimension, r, table_r),
                            callback=CB)
P.close()
P.join()

A: A crude lower bound is given by
$E(Y) \gt \frac{2 \pi}{\sqrt{27}} (\frac{R}{r})^2$.
This follows by first considering the placement of radius-$r$ disks non-randomly to cover the larger radius-$R$ disk. According to a paper by G. F. Tóth (p. 260), the number of radius-$r$ disks needed to do this is greater than $m = \frac{2 \pi}{\sqrt{27}} (\frac{R}{r})^2$; consequently, random placement of these disks can attain total coverage only if there are more than $m$ of them, implying $Y \gt m$, and hence $E(Y) \gt m$.
