My friend John likes to go to the cinema. He can choose between system A and system B.
```
System A : he buys a ticket (15 dollars) every time
System B : he buys a card (500 dollars) and a first ticket for 0.90 times the ticket price, 
then for each additional ticket he pays 0.90 times the price paid for the previous ticket.
```
#Example: 
If John goes to the cinema 3 times:
```
System A : 15 * 3 = 45
System B : 500 + 15 * 0.90 + (15 * 0.90) * 0.90 + (15 * 0.90 * 0.90) * 0.90 ( = 536.5849999999999, no rounding for each ticket)
```
John wants to know how many times he must go to the cinema so that the *final result* of System B, when rounded *up* to the next dollar, will be cheaper than System A.

The function `movie` has 3 parameters: `card` (price of the card), `ticket` (normal price of 
a ticket), `perc` (fraction of what he paid for the previous ticket) and returns the first `n` such that
```
ceil(price of System B) < price of System A.
```
More examples:
```
movie(500, 15, 0.9) should return 43 
    (with card the total price is 634, with tickets 645)
movie(100, 10, 0.95) should return 24 
    (with card the total price is 235, with tickets 240)
```

Difficulty: introductory

Starter code:

def movie(card, ticket, perc):
	

Solutions:
import math 

def movie(card, ticket, perc):
 num = 0
 priceA = 0
 priceB = card
 
 while math.ceil(priceB) >= priceA:
  num    += 1
  priceA += ticket
  priceB += ticket * (perc ** num)
  
 return num

from itertools import takewhile, count, accumulate
def movie(card, ticket, perc):
    sys_b = accumulate(ticket*perc**n for n in count(1))
    sys_a = accumulate(ticket for m in count(1))
    return sum(1 for a in takewhile(lambda x: round(x[0] + card + 0.49) >= x[1], zip(sys_b, sys_a))) + 1

from itertools import count
from math import ceil
def movie(card, ticket, perc):
    return next(n for n in count(1) if ceil(card + ticket * perc * (1 - perc ** n) / (1 - perc)) < ticket * n)

from itertools import count
from math import ceil


def movie(card, ticket, perc):
    return next( x for x in count(card//ticket)
                 if ticket * x > ceil(card + ticket * perc * (1 - perc**x)/(1 - perc)) )

import math
def movie(card, ticket, perc):
    sysA, sysB, count = ticket, card+ticket*perc, 1
    while sysA <= math.ceil(sysB):
        sysA += ticket
        sysB += ticket*(perc**(count+1))
        count+=1
    return count

from math import ceil

def movie(card, ticket, rate):
    count = 0
    totalA = 0.0
    totalB = 0.0
    
    while (ceil(card + totalB) >= totalA):
        totalA += ticket
        totalB = (totalB + ticket) * rate
        count += 1

    return count


from math import ceil
def movie(card, ticket, perc):
    n = 0;
    while 1:
        n+= 1
        if ticket*n>ceil(card+ticket*perc*(1-perc**n)/(1-perc)):
            return n

def movie(card, ticket, perc, n = 1):
    while card + ticket*perc*(1-perc**n)/(1-perc) - ticket*n > -1: 
        n += 1
    return n

def movie(card, ticket, perc, cnt = 0):
    while card>-1:
        card += (ticket * perc**cnt)*perc - ticket
        cnt += 1
    return cnt

from math import *
def movie(card, ticket, perc):
    n = 1
    while ceil(card + ticket*perc*(1-perc**n)/(1-perc)) >= ticket*n: n += 1
    return n

import math

def movie(card, ticket, perc):
    total = card
    n = 1
    while True:
        total += ticket*(perc**n)
        if math.ceil(total) < ticket*n:
            break
        n += 1
    return n


import math
def movie(card, ticket, perc):
  sysa=n=0
  sysb=card
  while math.ceil(sysb) >= (sysa):
    n+=1
    sysa += ticket
    sysb += ticket * math.pow(perc,n)
  else: return n


import math
def movie(card, ticket, perc):
    n = 0
    a_price = 0
    b_price = card
    perc_multiplier = perc
    while math.ceil(b_price) >= a_price:
        a_price += ticket
        b_price += ticket * perc_multiplier
        perc_multiplier *= perc
        n += 1
    return n
        


import math
def movie(card, ticket, perc):
    pc = card
    pt = 0
    count = 0
    while not math.ceil(pc) < math.ceil(pt):
        count += 1
        pc += ticket * (perc**count)
        pt += ticket
    return count

from math import ceil

def movie(card, ticket, perc):
    i = 0; sb = card; sa = 0; prev = ticket
    while True: 
        i += 1
        nou = prev * perc
        sb += nou
        prev = nou
        sa += ticket 
        if (ceil(sb) < sa): 
            return i 

from scipy.special import lambertw
from math import ceil, log

def movie(a, b, c):
    log_c = log(c)
    w = lambertw(
        (c ** (a / b + c / (1 - c) + 1 / b + 1) * log_c) /
        (1 - c)).real
    return int(ceil((
        b * w - b * c * w -
        a * log(c) + a * c * log_c - b * c * log_c + c * log_c - log_c
    ) / (b * (c - 1) * log_c)))

from itertools import count
from scipy.special import lambertw
from math import log

def movie(a, b, c):
    if a>0:
        w = lambertw(-c**((a/b)+c/(1-c)+1)*log(c)/(c-1))
        x = (b*w-b*c*w-a*log(c)+a*c*log(c)-b*c*log(c))/(b*(c-1)*log(c))
        x = int(x.real+1)
        A = b*x
        B = a+b*sum(c**e for e in range(1,x+1))
        for i in range(x, x+5):
            print(i, A, int(B+1))
            if A>int(B+1):
                return i
            A += x
            B += b*c**i
    return 2

def movie(card, ticket, perc):
    return next(n for n in range(9**99) if card + ticket*perc*(1-perc**n)/(1-perc) - ticket*n < -1)

def movie(card, ticket, perc):
    asum = -1
    cnt = 0
    while card>asum:
        asum += ticket
        card += (ticket * perc**cnt)*perc
        cnt += 1
    return cnt

from math import ceil

def movie(card, ticket, perc):
    # your code
    discount_ticket = ticket
    system_a_price = 0
    system_b_price = card
    days = 0
    while ceil(system_b_price) >= system_a_price:
        days = days + 1
        discount_ticket = discount_ticket * perc
        system_a_price = days * ticket
        system_b_price = system_b_price + discount_ticket
    return days


def movie(card, ticketA, perc):
    assert perc < 1
    
    ticketB = ticketA
    priceA = times = 0
    priceB = card
    
    while not priceA > -(-priceB // 1):
        ticketB *= perc
        priceA += ticketA
        priceB += ticketB
        times += 1
        
    return times


import math
def movie(card, ticket, perc):
    # we want
    # ticket*n > card + ticket*sum(p^i,where i=1 to n)
    # we use the geom series formula to simplify sum()
    n = 0
    while True:
        n += 1
        A = ticket*n
        B = card + ticket*(perc*(1-perc**n)/(1-perc))
        if math.ceil(B) < A:
            break
            
    return n


import math
def movie(card, ticket, perc):
    a,b,n = 0,card,0
    while math.ceil(b) >= a:
        n += 1
        a += ticket
        b += ticket * (perc ** n) 
    return n

from itertools import count
from math import ceil

def movie(card, ticket, perc):
    A = lambda n: ticket * n
    B = lambda n: card + ticket * ((perc * (perc ** n - 1)/(perc - 1)))
    return next(n for n in count(1) if ceil(B(n)) < A(n))

import math
def movie(card, ticket, perc):
    n = 1
    while 1:
        if (ticket * n > card +  math.ceil(ticket * (1 - pow(perc, n)) / (1 - perc))):
            return n-1
        n = n+1

import math
def movie(card, ticket, perc):
    x = 1
    systema = 0
    systemb = card
    while systemb >= systema:
        systema = ticket*x
        systemb += ticket*perc**x
        if math.ceil(systemb) < systema:
            break
        else:
            x += 1
    return x

from math import ceil
def movie(card, ticket, perc):
    prevPrice = ticket
    i = 0
    
    while True:
        if ceil(card) < ticket * i: return i
        prevPrice *= perc
        card += prevPrice
        i += 1

import math
def movie(card, ticket, perc):
    n=card//ticket
    system_go=True
    while system_go:
        system_A=ticket*n
        system_B=card+sum([ticket*perc**x for x in range(1,n+1)])
        if system_A<card:
            n+=1
            continue
        if system_A>math.ceil(system_B):
            return n
            break
        else:
            n+=1

import math
def movie(card, ticket, perc):
    tiks = 0
    sysA = 0
    sysB = card
    Bticket = ticket

    while math.ceil(sysB) >= sysA:
        sysA+=ticket
        tiks+=1
        Bticket*=perc
        
        sysB+= Bticket

    return tiks


def movie(card, ticket, perc):
    import math
    
    count = 1
    
    priceA = card;  
    priceB = 0
    
    while True:
        priceB += ticket       
        
        priceDecrease = ticket * pow(perc, count)
        priceA += priceDecrease
                
        if priceB > math.ceil(priceA):
            return count
        
        count += 1


import math

def system_a(ticket,times):
    price_a=ticket*times
    return price_a

def system_b(card,ticket,perc,times):
    price_b = 0
    it = perc * ticket
    
    for i in range(0,times):
        price_b=price_b + it 
        it = it * perc
    price_b=price_b+card
    return price_b

def movie(card, ticket, perc):
    times=1
    systemb = card + ticket * perc
    while (math.ceil(systemb) >= system_a(ticket, times)):
        systemb = systemb + perc ** (times+1) * ticket
        times=times+1
    return times

from math import ceil

def movie(card, ticket, perc):
    n=0
    ap=0
    bp=card
    price=ticket
    while ap<=ceil(bp):
        n+=1
        ap+=ticket
        price=price*perc
        bp+=price
    return n

from math import ceil
def movie(card, ticket, perc):
    a,b,c = 0,card,0
    while ceil(b) >= ceil(a):
        a += ticket
        b += ticket * perc**c
        c += 1
    return c-1

from math import ceil
def movie(card, ticket, perc):
    true = ticket
    sys_b = card
    count = 0
    while True:
        count += 1
        sys_a = count*true
        ticket = perc*ticket
        sys_b += ticket
        if ceil(sys_b)<sys_a:
            return count
    return count


import math

def movie(card, ticket, perc):
    curr_card_price = card
    curr_ticket_price = 0
    next_card_purchase = ticket * perc
    trips = 0
    
    while math.ceil(curr_card_price) >= curr_ticket_price:
        curr_card_price += next_card_purchase
        curr_ticket_price += ticket
        
        trips += 1
        next_card_purchase *= perc

    return trips

import math
def movie(card, ticket, perc):
    Aval, Bval, res = ticket, card + (ticket*perc), 1
    while math.ceil(Bval) >= Aval:
        res += 1
        Aval += ticket
        Bval += ticket*(perc**res)
    return res

from math import ceil

def movie(card, ticket, perc):
    N=1
    while ticket*N<=ceil(card+ticket*perc*(1-perc**N)/(1-perc)):N+=1
    return N

import math

def movie(card, ticket, perc):
    finnished = False 
    n = 0
    previous_total = 0 
    while not finnished:
        n += 1
        a = ticket * n
    
        previous_total += (ticket*(perc**n)) 
        b = math.ceil(card + previous_total) 
        
        if a > b:
            finnished = True
        
    return n
            
            


from math import ceil

def movie(card, ticket, perc):
    n = 0
    total = card
    while (ceil(total) >= n*ticket):
        total += ticket*perc**n
        n += 1
        
    return n-1

from math import ceil
def movie(card, ticket, perc):
    counter = 0
    sum = card
    perc_= perc
    while ceil(sum) >= ticket*counter:
        sum += ticket*perc_
        perc_ *= perc
        counter += 1
    return counter     

def movie(card, ticket, perc):
    print((card, ticket, perc))
    import math
    total_ticket = 0.0
    total_card = card
    count = 0
    movieprice_bycard = ticket
    while total_ticket <= math.ceil(total_card):
        count += 1
        movieprice_bycard *= perc
        total_ticket += ticket
        total_card += movieprice_bycard
    return count


import math
def movie(card, ticket, perc):
    sys_a = 0
    sys_b = card
    i = 1
    while sys_a <= math.ceil(sys_b):
        sys_a+=ticket
        sys_b+=ticket*(perc**i)
        i+=1
    return i-1

def movie(card, ticket, perc):
    temp = ticket
    rA = 0
    rB = card
        
    while rB > rA-1:
        temp=temp*perc
        rB+=temp
        rA+=ticket
    
    print((str(rB), ":", str(rA)))
    return int(rA/ticket)


from math import ceil
def movie(card, ticket, perc):
    cs, ts, i = card+ticket*perc, ticket, 2
    while ceil(ts)<=ceil(cs):
        cs, ts, i = cs + ticket*perc**i, ts + ticket, i + 1
    return i-1


import math
def movie(crd,tkt,pcnt):

    tktCnt = TotalA = TotalB = 0
    
    while(math.ceil(TotalB) >= TotalA):
        tktCnt+=1
        TotalA = tkt * tktCnt
        TotalB = crd + tkt*((pcnt*((pcnt**tktCnt) - 1))/(pcnt - 1))

    return(tktCnt)

from math import ceil
def movie(card, ticket, perc):
    priceA=ticket
    priceB=card+ticket*perc
    n=1
    while ceil(priceB) >= priceA:
        n+=1
        priceA+=ticket
        priceB+=ticket*perc**n
    return n        

from math import *
def movie(card, ticket, perc):
    n = 0
    seance = 0
    a = card
    ticket_abonnement = 0
    while ceil(a + ticket_abonnement) >= (ticket * seance) :
            ticket_abonnement += (ticket * perc) * perc**n
            n += 1
            seance += 1
    return seance

from math import ceil
def movie(card, ticket, perc):
    priceOfSystemA, priceOfSystemB, n, ticketPriceB = 0, card, 0, ticket
    while ceil(priceOfSystemB) >= priceOfSystemA:
        n += 1
        priceOfSystemA += ticket
        ticketPriceB *= perc
        priceOfSystemB += ticketPriceB
    return n

import math

def movie(card, ticket, perc):
    num_trips = 0
    card_cost = card
    ticket_cost = 0
    while math.ceil(card_cost) >= ticket_cost:
        num_trips += 1
        card_cost += ticket * (perc ** num_trips)
        ticket_cost += ticket
    return num_trips

import math
def movie(card, ticket, perc):
    reduced = ticket*perc
    total = card + reduced
    n=1
    while math.ceil(total) >= ticket * n:
        reduced *= perc
        total += reduced
        n += 1
    return n

def movie(card, ticket, perc):
    import math
    n=1
    s1=ticket
    s2=card+ticket*perc
    while s1<=math.ceil(s2):
        n+=1
        s1=ticket*n
        s2+=ticket*perc**n
    return n

import math

def movie(card, ticket, perc):
    n = 1
    ticket_b = ticket
    ticket_total = 0
    sys_a = ticket
    sys_b = card+ticket 
    c = ((sys_b))/((sys_a))
    if (c < 1) :
        return 1
        exit 
    else: 
        while True:
            sys_a = (n) * ticket
            ticket_b = ticket_b * perc
            ticket_total = ticket_total + ticket_b
            sys_b = card + ticket_total 
            if (math.ceil(sys_b) < sys_a ):
                return n
            else : 
                n +=1
    return n

import math
def movie(card, ticket, perc):
    i = 1
    lhs = lambda: ticket * i
    rhs = lambda: math.ceil(card + ticket*(1-perc**i)/(1-perc))
    
    while lhs() <= rhs():
        i *= 2
    
    low = i/2-1
    high = i+1
    
    while low+1 != high :
        i = (low + high)//2
        if lhs() <= rhs():
            low = i
        else :
            high = i
    
    p_lhs = lhs()
    i += 1
    if p_lhs > rhs():
        return i-2
    return i-1

import math
def movie(card, ticket, perc):
    i = 1
    lhs = lambda: ticket * i
    rhs = lambda: math.ceil(card + ticket*(1-perc**i)/(1-perc))
    
    while lhs() <= rhs():
        i += 1
        
    return i-1

import math

def movie(card, ticket, perc):
    number_of_tickets = 0
    scenario_a = 0
    scenario_b = 1
    
    while scenario_a <= scenario_b:
        number_of_tickets += 1
        scenario_a = number_of_tickets * ticket
        scenario_b = math.ceil(card + ticket * (1 - perc ** number_of_tickets) / (1 - perc))     
    return number_of_tickets-1
                


from math import ceil

def movie(card, ticket, perc):
    num = 0
    priceA = 0
    priceB = card
    while ceil(priceB) >= priceA:
        num += 1
        priceA += ticket
        priceB += ticket * (perc ** num)
    return num

import math
def movie(card, ticket, perc):
    n = 0
    A = 0.0
    B = card
    while math.ceil(B) >= A:
        n += 1
        A += ticket
        B += ticket * (perc ** n)
    return n

def movie(card, ticket, perc):
    from math import ceil
    
    b = card
    n = 1
    while True:
        a = ticket * n
        b = b + ticket * perc**n
        if b + 1 < a:
            return n
        else:
            n = n + 1

import math
def movie(card, ticket, perc):
    sys_A, sys_B, count = ticket, card+ticket*perc, 1
    while sys_A <= math.ceil(sys_B):
        sys_A += ticket
        sys_B += ticket*(perc**(count+1))
        count+=1
    return count

import math
def movie(card, ticket, perc):
    # your code
    times = 0
    price_A = 0
    price_B = card 
    
    while(math.ceil(price_B)>=price_A):
        times+=1
        price_A+=ticket
        price_B += ticket*(perc ** times)
    
    return times 
    
        



import math
def movie(card, ticket, perc):
    # your code
    times = 0
    price_A = 0
    price_B = card 
    
    while(math.ceil(price_B)>=price_A):
        times+=1
        price_A+=ticket
        price_B = price_B+ticket*(perc ** times)
    
    return times 
    
        



from math import *
def movie(card, ticket, perc):
    n=0
    priceA=0
    priceB=card
    while ceil(priceB)>=priceA:
        n+=1
        priceA+=ticket
        priceB+=ticket*(perc**n)
    return n

import math

def movie(card, ticket, perc):
    sys_a = 0
    sys_b = card
    time = 0
    while sys_a <= math.ceil(sys_b):
        time += 1
        sys_a = ticket * time
        sys_b += ticket * (perc ** time)
    return time

import math

def movie(card, ticket, perc):
    
    x = 0
    price1 = 0
    price2 = card
    
    while math.ceil(price2) >= price1:
        
        x +=1
        price1 += ticket
        price2 += ticket * perc ** x
        
    return x

import math

def movie(card, ticket, perc):
    temp, spend_a, spend_b = 1, 0, 0
    
    while spend_a <= math.ceil(spend_b):
        
        spend_a += ticket
        
        if temp == 1:
            spend_b += card + ticket * perc
        else:
            spend_b += ticket * math.pow(perc,temp)
        
        temp += 1
        
    return temp-1

from math import ceil

def movie(card, ticket, perc):
    answer = 1
    systemA = 0
    systemB = card
    while answer > 0:
        systemA += ticket
        systemB += ticket*(perc**answer)
        if ceil(systemA) > ceil(systemB):
            return answer
        answer += 1

def movie(card, ticket, perc):
    result = 1
    B = card+ticket*perc
    while ticket*result < B+1:
        result += 1
        B += ticket*perc**result
    return result

import math

def movie(card, ticket, perc):
    PriceA = 0
    PriceB = card
    n = 0
    while PriceA <= math.ceil(PriceB):
        n += 1
        PriceA += ticket
        PriceB += ticket * (perc ** n)
    return n

def movie(card, ticket, perc):
    B = card
    A = 0
    n = 0
    t = ticket
    while A <= int(B)+ 1:
        A += ticket
        t *= perc
        B += t
        n += 1
    return n 

import numpy as np
def movie(card, ticket, perc):
    # system A - buying tickets
    # system B - buying card and then tickets
    # wartosci, ktore wchodza do petli while:
    licznik = 0
    sysA = 0
    sysB = card # * ticket * perc
    tic_B = ticket
    while np.ceil(sysA) <= np.ceil(sysB): # rozpoczyna sie nowy obieg
        licznik += 1 # wiec go uwzgledniam
        sysA += ticket
        tic_B *= perc
        sysB += tic_B
    return licznik

from math import ceil

def movie(card, ticket, perc):
    i=1
    card=card+ticket*perc
    while True:
        if ceil(card) < i*ticket:
            return i
        else:
            i+=1
            card += ticket*(perc**i)


from math import ceil

def movie(card, ticket, perc):
    sysa = 0
    sysb = card
    ratio = ticket * perc
    times = 0
    
    while sysa <= ceil(sysb):
        sysa += ticket
        sysb += ratio
        ratio *= perc
        times += 1

    return times

import math

def movie(card, ticket, perc):
    a, tc = 0, 0
    tc2 = ticket
    while math.ceil(card) >= tc:
        a += 1
        ticket = ticket * perc
        tc += tc2
        card += ticket
    return a

def movie(card, ticket, perc):
    ticketsBought = 0

    a = 0
    b = card
    while (round(b,0) >= a):
        discount = pow(perc, ticketsBought)
        b += ticket * discount
        ticketsBought += 1

        a += ticket
        
    if (b > round(b, 0)):
        b += 1
        
    if (a > b):
        return ticketsBought - 1
    else:
        ticketsBought += 1
        return ticketsBought -1
        
    print(f"a:{a}, b:{b}")
    print(f"ticketsBought:{ticketsBought - 1}")
    return ticketsBought - 1

import math

def movie(card, ticket, perc):
    A = 0
    B = card
    i = 0
    
    while math.ceil(B) >= A:
        i = i+1
        A = A + ticket
        B = B + ticket*perc**i
        
    return i

    # your code


def movie(card, ticket, perc):
    import math
    i = 0
    sys_A = 0
    sys_B = card
    while True:
        i += 1
        sys_B += ticket*(perc**i)
        sys_A += ticket
        if math.ceil(sys_B) < sys_A:
            return i

import math 
def movie(card, ticket, perc):
    n = 0
    c = 0
    x = ticket
    while c <= math.ceil(card):
        n += 1
        c += ticket
        x *= perc
        card += x
    return n

from math import ceil

def movie(c, t, p):
    n = 1
    while ceil(c + p * t * ((p ** n - 1) / (p - 1))) >= n * t:
        n += 1
    return n

import math
def movie(card, ticket, perc):
    sysA = ticket
    sysB = ticket*perc
    count = 1
    while card+math.ceil(sysB) >= sysA:
        sysA+=ticket
        sysB = (sysB) + (ticket)*(perc**(count+1))
        count+=1
        
    return count

def movie(c, t, p):
    s = c
    n = 1 
    while True:
        summation = (1 - p**(n+1))/(1-p) - 1
        if int(s + t*summation)+1 < n*t:
            break
        n += 1
    return n


import math
def movie(card, ticket, perc):
    #System B
    price_A = 0
    visits = 0
    while math.ceil(card) >= price_A:
        price_A += ticket
        card += ticket * (perc ** visits)
        visits += 1
    return visits -1

def movie(card, ticket, perc):
    import math    
    n = 1
    while n * ticket -card <= math.ceil(ticket* (perc**n - 1)/(perc -1)):
        n +=1
    return n-1

def movie(card, ticket, perc):
    numero_de_tickets = 0
    novo_valor_do_ticket = ticket * perc
    valor_inteiro_do_ticket = 0
    while valor_inteiro_do_ticket <= int(card) + 1:
        card += novo_valor_do_ticket
        valor_inteiro_do_ticket += ticket
        novo_valor_do_ticket *= perc
        numero_de_tickets += 1
    return numero_de_tickets

import math
def movie(card, ticket, perc):
    a = 0
    b = card
    n = 0
    while math.ceil(b) >= a:
        n += 1
        a += ticket
        b += ticket * (perc ** n)
    return n

import math
def movie(card, ticket, perc):
    tickets = 1
    system_a = ticket
    system_b = card + (ticket * perc)
    while True:
        if math.ceil(system_b) < system_a:
            return tickets
        tickets += 1
        system_a += ticket
        system_b += ticket * perc ** tickets

def movie(card, ticket, perc):
    import math
    
    sysa = 0
    sysb = card
    tickets = 0
    while True:
        tickets += 1
        sysa += ticket
        sysb += ticket * (perc ** tickets)
        
        if math.ceil(sysb) < sysa:
            return tickets

import math
def movie(card, ticket, perc):
    tickets = 1
    ticket_a = ticket
    ticket_b = card+ticket*perc
    while True:
        if math.ceil(ticket_b) < ticket_a:
            return tickets
        ticket_a += ticket
        ticket_b += ticket*(perc**(tickets+1))
        tickets += 1

from math import ceil

def movie(card, ticket, perc):
    n = 1
    p = card + ticket*perc
    while ceil(p)>=n*ticket:
        n += 1
        p += ticket*(pow(perc,n))
    return n

import math

def movie(card, ticket, perc):
    v=0
    i=0
    while 1:
        i=i+1
        if i==1:
            v=ticket*perc
            
        elif i>1:
            v=(v*perc)
        
        card += v
                    
        if math.ceil(card) < (ticket*i):
            return i

        
        

    


def movie(card, ticket, perc):
    import math
    SystemB = card
    for num in range(1,500_000):
        SystemB += ticket * perc ** num
        if num * ticket > math.ceil(SystemB):
            break
    return num

def movie(card, ticket, perc):
    A,B = ticket,card+(ticket*perc)
    prev,count = ticket*perc, 1
    while A <= int(B)+1:
        count +=1
        prev = prev*perc
        A += ticket
        B += prev
    return count


from math import ceil
def movie(card, ticket, perc):
    n=1
    while True:
        card = card+ticket*perc**n
        ticket_price = ticket*n
        if ticket_price > ceil(card):
            return n
        n+=1


from math import ceil
def movie(card, ticket, perc):
    n=0
    while True:
        n+=1
        sysA=ticket*n
        sysB=ceil(card + ticket*perc*(1-perc**n)/(1-perc))
        if sysA>sysB:
            return n


import math
def movie(card, ticket, perc):
    system_a: int = 0
    n: int = 0

    system_b = card
    ticket_b = ticket * perc

    while system_a <= math.ceil(system_b):
        n += 1
        system_a = ticket * n
        system_b += ticket_b
        ticket_b = ticket_b * perc

    system_b = math.ceil(system_b)
    print(f'system A price is {system_a}')
    print(f'system B price is {system_b}')
    return n

def movie(a, b, c):
    import math
    for n in range(500000):
        if n*b>   math.ceil(a+b*(1-c**n)/(1-c)):
            return n-1

import math
def movie(card, ticket, perc):
    priceA = 0
    priceB = card
    visits = 0
    while priceA <= math.ceil(priceB):
        visits += 1
        priceB += ticket * perc**visits
        priceA += ticket
    return visits


from math import ceil



def movie(card, ticket, rate):
    count = 0
    totala = 0.0
    totalb = 0.0

    while (ceil(card + totalb) >= totala):
        totala += ticket
        totalb = (totalb + ticket) * rate
        count += 1

    return count


import math
def movie(card, ticket, perc):
    count=0
    system_A=0
    system_B=card
    while math.ceil(system_B) >= system_A:
        count+=1
        system_A+=ticket
        system_B+=ticket*(perc**count)
        #count+=1
    return count

import math
def movie(card, ticket, perc):
    a, count = ticket, 1
    ticket_p = perc*ticket
    b = card + ticket_p
    while a <= math.ceil(b):
        a += ticket
        ticket_p *= perc
        b += ticket_p
        count += 1
    return count