Expected sum of cards until first Ace I came across this question while preparing for an interview.
You draw cards from a $52$-card deck until you get first Ace. After each card drawn, you discard three cards from the deck. What's the expected sum of cards until you get the first Ace? 
Note


*

*J, Q, K have point value 11, 12 and 13, and Ace has point value 1

*discarded cards don't count towards the sum and if we don't get an Ace we shuffle the deck and continue

*when you shuffle, you shuffle all cards but you keep the sum, and when you draw a new card you add it to that sum (you don't start from zero after each shuffle) 
My thought so far: the expected sum is definitely between $73$ and $91$.
$73$ is the expected sum if we don't discard any cards, so the problem simply becomes the expected sum until first Ace, that is, $(2+\dots+13) \cdot 4 \cdot \frac{1}{5}+1$.
$91$ is the expected sum if we discard all $51$ remaining cards (shuffle the deck after each draw). In this case the number of draws needed to see the first Ace follows a Geometric distribution, so the answer is $(\frac{52}{4}-1) \cdot 7.5+1$
Any help is appreciated!!! 
 A: Although an exact solution is complicated and worth more thoughts, I did a quick simulation which hopefully can provide some insights.
Expected sum v.s. number of cards thrown
Essentially the plot above demonstrates how the expected sum till first ACE changes with respect to the number of cards thrown after each draw. One can see that the increase is slower than linear – it might be even slightly slower than logarithm, as can be seen from the red curve.
I am also presenting the codes for the simulation in case someone else is interested in more investigation. On the other hand, I think that it will be more exciting to approach the problem exactly, for which I have an idea, but it involves very lengthy calculation that may leads to nowhere at all…
class Cards(object):

def __init__(self):
    self.c = np.asarray([4]*13) 

    ### a length-13 list containing the number of remaining cards of each number 
    ###i.e. A,2,3,...,13

    self.s = np.sum(self.c)

    self.r = np.arange(1,14)

def draw_card(self):
    if self.s <= 0: ### Enter a new deck
        self.c = np.asarray([4]*13)
        self.s = np.sum(self.c)

    card = choice( self.r, p = self.c/self.s )
    self.c[card-1] -= 1
    self.s -= 1 

    return card

def throw_cards(self,num=3):

    ### assert num > 0, "Number of cards to be thrown away is zero!"

    if num <= 0:
        return

    if self.s >= num:
        for n in xrange(num):
            card = choice( self.r, p = self.c/self.s )
            self.c[card-1] -= 1
            self.s -= 1
    else: 
        ### self.s < num; number of remaining cards < number of cards to be thrown away
        ### Enter a new deck 
        self.c = np.asarray([4]*13) 
        ### a length-13 list containing the number of remaining cards of each number i.e. A,2,3,...,13
        self.s = np.sum(self.c)
    return 

def exp_sum(self,num=3,maxiter=200):
    es = 0
    it = 0
    while it < maxiter:
        it += 1

        card = self.draw_card()
        es += card 
        if card == 1:
            break 
        else: ### card != 1
            self.throw_cards(num)

    ### Reset self.c and self.r
    self.c = np.asarray([4]*13) 
    self.s = np.sum(self.c)
    return es

