Mr. Scrooge has a sum of money 'P' that he wants to invest. Before he does, he wants to know how many years 'Y' this sum 'P' has to be kept in the bank in order for it to amount to a desired sum of money 'D'.

The sum is kept for 'Y' years in the bank where interest 'I' is paid yearly. After paying taxes 'T' for the year the new sum is re-invested.

Note to Tax: not the invested principal is taxed, but only the year's accrued interest

Example:

      Let P be the Principal = 1000.00      
      Let I be the Interest Rate = 0.05      
      Let T be the Tax Rate = 0.18      
      Let D be the Desired Sum = 1100.00


    After 1st Year -->
      P = 1041.00
    After 2nd Year -->
      P = 1083.86
    After 3rd Year -->
      P = 1128.30
  
Thus Mr. Scrooge has to wait for 3 years for the initial principal to amount to the desired sum.
 
Your task is to complete the method provided and return the number of years 'Y' as a whole in order for Mr. Scrooge to get the desired sum.  

Assumption: Assume that Desired Principal 'D' is always greater than the initial principal. However it is best to take into consideration that if Desired Principal 'D' is equal to Principal 'P' this should return 0 Years.

Difficulty: introductory

Starter code:

def calculate_years(principal, interest, tax, desired):
	

Solutions:
def calculate_years(principal, interest, tax, desired):
    years = 0
    
    while principal < desired:
        principal += (interest * principal) * (1 - tax)
        years += 1
        
    return years


from math import ceil, log

def calculate_years(principal, interest, tax, desired):
    if principal >= desired: return 0
    
    return ceil(log(float(desired) / principal, 1 + interest * (1 - tax)))


def calculate_years(principal, interest, tax, desired):
    years = 0
    if principal == desired:
        return years
    while principal < desired:
        x = principal * interest
        y = x * tax
        principal = principal + x - y
        years += 1
    return years


from math import ceil, log

def calculate_years(principal, interest, tax, desired):
    return ceil(log(float(desired) / principal, 1 + interest * (1 - tax)))

def calculate_years(principal, interest, tax, desired):
    year = 0
    while (principal < desired):
        increment = principal * interest * (1-tax)
        principal = principal + increment
        year = year + 1
    return year

import math

def calculate_years(principal, interest, tax, desired):
    return 0 if principal >= desired else math.ceil((math.log(desired) - math.log(principal))/math.log(1+interest*(1-tax)))

def calculate_years(p, i, t, d, n=0):
    if p >= d:
        return n
    p = p + p * i * (1 - t)
    return calculate_years(p, i, t, d, n+1)

def calculate_years(principal, interest, tax, desired):
    return 0 if principal >= desired else 1 + calculate_years(principal * (1+interest*(1-tax)), interest, tax, desired)

def calculate_years(principal, interest, tax, desired):
    
    years = 0
    
    while principal < desired : 
        years += 1
        principal = principal + (principal*interest) - (principal*interest*tax)
    
    return years

calculate_years = lambda p,i,t,d,n=0: calculate_years(p+(p*i*(1-t)),i,t,d,n+1) if p<d else n

from math import ceil, log
def calculate_years(P, I, T, D):
    return ceil((log(D)-log(P))/log(1+I*(1-T)))

def calculate_years(principal, interest, tax, desired):
    y=0
    while principal<desired:
        extra=principal*interest
        principal+=extra-tax*extra
        y+=1
    return y

from math import ceil, log

def calculate_years(p, i, t, d):
    x = float(d) / p
    base = 1 + (i * (1 - t))
    return ceil(log(x, base))

    #return ceil(log(float(d) / p, 1 + (i * (1 - t))))


def calculate_years(principal, interest, tax, desired):
    x = 0
    while principal < desired:
        add = principal * interest
        add = add - (add * tax)
        principal = principal + add
        x = x + 1
    return x

import math
def calculate_years(principal, interest, tax, desired):
    x = (float(desired)/float(principal))
    base = (1 + (float(interest) * ( 1 - float(tax))))
    years = math.log(x, base)
    return math.ceil(years)


def calculate_years(sum, intr, tax, goal):
    year, fix = 0, intr * (1 - tax) + 1
    while sum < goal:
        year += 1
        sum *= fix
    return year


def calculate_years(principal, interest, tax, desired):
    if desired == principal:
        return 0
    else:
        years = 0
        while principal < desired:
            principal += (principal * interest) - (principal * interest * tax)
            years += 1
        return years




def calculate_years(principal, interest, tax, desired):
    year = 0
    while principal < desired:
        realint = principal * interest
        realtax = realint * tax
        principal = principal + realint - realtax
        year += 1
    return year

import math
def calculate_years(principal, interest, tax, desired): 
    #if principal is lower than zero, than error with return code -1
    return -1 if principal < 0 else math.ceil(math.log(float(desired) / principal if principal else 1, 1 + interest * (1 - tax)))

def calculate_years(principal, interest, tax, desired):
    if principal == desired:
        return 0
    p = principal
    y = 0
    fixed = (1 + interest * (1 - tax))
    while p < desired:
        p *= fixed
        y += 1
    return y


def calculate_years(principal, interest, tax, desired):
    year = 0    
    while principal < desired:
        year = year + 1
        interest_beforetax = interest * principal
        principal = principal + ((1 - tax) * interest_beforetax)
        
    return year
        
    
    
  


def calculate_years(principal, interest, tax, desired):
    y = 0
    while desired > principal:
        y += 1
        principal = principal*(1+interest)-principal*interest*tax
    return y

def calculate_years(principal, interest, tax, desired):
    years = 0
    
    while principal < desired:
        a = principal * interest
        principal += a - (a * tax)
        years += 1
        
    return years

def calculate_years(principal, interest, tax, desired):
    years = 0
    while principal < desired:
        years += 1
        principal += principal * interest * ( 1 - tax)
    return years

calculate_years=lambda principal, interest, tax, desired, count=0: count if principal >= desired else calculate_years(principal * (1 + interest * (1 - tax)), interest, tax, desired, count + 1)


def calculate_years(p, i, t, d):
    y = 0
    while p < d:
        p = p + p*i - p*i*t
        y += 1
    return y

from math import log, ceil


def calculate_years(principal, interest, tax, desired):
    return ceil(log(float(desired)/principal, 1 + interest * (1 - tax)))

def calculate_years(p, i, t, d):
    years = 0
    while p < d: 
        p = (p*(1+i) - p*i*t)
        years += 1
    return years

import math


def calculate_years(principal, interest, tax, desired):
    year = 0
    if int(principal) >= int(desired):
        return (year)
    while principal <= desired:
        principal = (principal +(principal * interest)) - ((principal * interest)* tax)
        year += 1
        if int(principal) >= int(desired):
            return (year)


def calculate_years(principal, interest, tax, desired):
    years = 0
    gain = 0
    taxed = 0
    while principal < desired:
        years = years + 1
        gain = principal * interest
        taxed = gain * tax
        principal = principal + gain - taxed
        
        
    
    
    
    return years
    raise NotImplementedError("TODO: calculate_years")


import math

def calculate_years(principal, interest, tax, desired):
    if principal != desired:
        return int(math.log((desired*(1+interest-interest*tax))/(principal+principal*interest*(1-tax)), 1+interest-interest*tax))+1
    else:
        return 0

def calculate_years(principal, interest, tax, desired,years=0):
    if principal >= desired:
        return years
    principal += (principal * interest) * (1.0-tax )
    return calculate_years( principal, interest, tax, desired, years + 1 )
    


import math

def calculate_years(principal, interest, tax, desired):
    # P(1+IT)^Y = D
    return math.ceil(math.log(desired*1.0/principal, 1+interest*(1-tax)))
    


def calculate_years(principal, interest, tax, desired):

    if(principal >= desired):
        return 0
    else:
        gain = principal * interest
        taxed = gain * tax
        new_sum = principal + gain - taxed
        return 1 + calculate_years(new_sum, interest, tax, desired)

def calculate_years(p, i, t, d):  
    y = 0
    while p < d:
      p += p*(i*(1-t))
      y += 1
    return y

def calculate_years(principal, interest, tax, desired):
    years = 0
    while principal < desired:
        principal = principal * (1 + 1 * interest * (1 - tax))
        years += 1
    return years

def calculate_years(principal, interest, tax, desired):
#     raise NotImplementedError("TODO: calculate_years")
    years = 0
    if desired <= principal:
        return 0
    total_summ = principal
    while total_summ <= desired:

        summ_year = total_summ*interest
        summ_tax = summ_year * tax
        total_summ += summ_year - summ_tax
        print(total_summ)
        years += 1
        if total_summ >= desired:
            return years



def calculate_years(p, i, t, d):
    y = 0
    while p < d:
        y += 1
        cur_i = (p * i) * (1 - t)
        p += cur_i
    return y
        


def calculate_years(P, I, T, D):
    total = []
    while P < D:
        x = P*I
        y = x*T
        z = P+(x-y)
        total.append(z)
        P = z
    return len(total)


def calculate_years(principal, interest, tax, desired):
    years_required = 0
    current = principal
    while (current<desired):
        current+=current*interest*(1-tax)
        years_required+=1
    return years_required


def calculate_years(p, i, t, d):
    
    c = 0
    
    while p < d:
        p += (p * i) + (p * i) * - t
        c += 1

    return c


def calculate_years(principal, interest, tax, desired):
    year_counter = 0
    while principal < desired:
        year_counter += 1
        principal += principal * interest * (1-tax)
    return year_counter

def calculate_years(principal, interest, tax, desired):
    current = principal
    years = 0
    while current < desired:
        currentstep = (current * (1 + interest))
        taxloss = (currentstep - current) * tax
        current = currentstep - taxloss
        years += 1
    return years


def calculate_years(principal, interest, tax, desired):
    import math
    count = 1
    compounding = principal*interest*(1-tax) + principal
    if desired==principal:
        return 0
    while compounding < desired:        
        compounding = (compounding*interest*(1-tax) + compounding)
        count +=1
    return count
    


def calculate_years(principal, interest, tax, desired):
    years = 0
    if principal >= desired: return 0
    while True:
        yearly_interest = principal * interest
        principal = principal + yearly_interest - yearly_interest * tax
        years += 1
        if principal >= desired: break
    return years

def calculate_years(principal, interest, tax, desired):
    years = 0
    if principal == desired:
        return years
    else:
        while principal < desired:
            years += 1
            principal = principal + (principal * interest) * (1 - tax)
        return years

def calculate_years(prin, inter, tax, desired):
    yrs = 0
    while prin < desired: 
        prin = (prin*(1+(inter*(1-tax))))
        yrs += 1
    return yrs

import math
def calculate_years(principal, interest, tax, desired):
    # desired = principal*(1+(interest)*(1-tax))**n
    # desired/principal = (1+interest*(1-tax))**n
    # n = ln(d/p)/ln(1+eff Interest Rate)
    # return int(n)+1 if n>0 else 0
    effInt = interest*(1-tax)
    timeFloat = math.log(desired/principal)/math.log(1+effInt)
    if desired>principal:
        return int(timeFloat)+1
    else:
        return 0


def calculate_years(principal, interest, tax, desired):
    
    year_count = 0
    
    while principal < desired:
        principal += (interest * principal) * (1 - tax)
        
        year_count += 1
        
    return year_count