This program tests the life of an
evaporator containing a gas. 

We know the content of the evaporator (content in ml),
the percentage of foam or gas lost every day (evap_per_day)
and the threshold (threshold) in percentage beyond which
the evaporator is no longer useful.
All numbers are strictly positive.

The program reports the nth day (as an integer)
on which the evaporator will be out of use.

**Note** : Content is in fact not necessary in the body of the function "evaporator", you can use it or not use it, as you wish. Some people might prefer to reason with content, some other with percentages only. It's up to you but you must keep it as a parameter because the tests have it as an argument.

Difficulty: introductory

Starter code:

def evaporator(content, evap_per_day, threshold):
	

Solutions:
def evaporator(content, evap_per_day, threshold):
    n = 0
    current = 100
    percent = 1 - evap_per_day / 100.0
    while current > threshold:
        current *= percent
        n += 1
    return n

import math

def evaporator(content, evap_per_day, threshold):
    return math.ceil(math.log(threshold / 100.0) / math.log(1.0 - evap_per_day / 100.0))


from math import log,ceil

def evaporator(content, evap_per_day, threshold):
    return ceil(log(threshold/100,1-evap_per_day/100))

import math
def evaporator(content, evap_per_day, threshold):
    return int(math.ceil(math.log(threshold/100.0, 1.0-evap_per_day/100.0)))

def evaporator(content, evap_per_day, threshold):
    thresholdper = threshold/100
    amount_remaining = content
    days = 0
    while amount_remaining/content >= thresholdper:
        amount_remaining = amount_remaining * (1 - (evap_per_day/100))
        days += 1
    return days

from math import *
def evaporator(content, evap_per_day, threshold):
    return ceil(log(threshold/100, 1-evap_per_day/100))

def evaporator(content, evap_per_day, threshold):
    print(content, evap_per_day, threshold)
    i = 0
    c = 1
    while c >= threshold/100:
        c *= 1 - evap_per_day/100
        i += 1
    return i

import math
def evaporator(content, evap_per_day, threshold):
  evap_per_day, threshold = evap_per_day / 100.0, threshold / 100.0
  return math.ceil(math.log(threshold) / math.log(1 - evap_per_day))

from math import ceil, log
def evaporator(c, e, t):
    return ceil(log(t/100, 1-(e/100)))

def evaporator(content, evap_per_day, threshold):
    thres = content * threshold/100
    count = 0
    while content > thres:
        content = content - content * evap_per_day/100
        count += 1
    return count

def evaporator(content, evap_per_day, threshold):
    
    limit = (content * threshold) / 100
    days = 0
    while content > limit:
        days += 1
        content = content - ((content * evap_per_day)/100)
    return days

from math import log2, ceil
def evaporator(content, evap_per_day, threshold):
  return ceil(log2(threshold/100.0) / log2((1-evap_per_day/100.0)))

def evaporator(content, evap_per_day, threshold):
    day = 0
    p = content/100*threshold
    while content >= p:
        day+=1
        perc = content / 100 * evap_per_day
        content -= perc
    return day


from math import log

def evaporator(_content, evap_per_day, threshold):
    return int(log(threshold / 100, 1 - evap_per_day / 100) + 1)

def evaporator(content, evap_per_day, threshold):
    from math import log, ceil
    return ceil(log(threshold/100) / log(1 - evap_per_day/100))

def evaporator(initial_volume, evap_per_day, threshold):
  threshold = float(threshold)
  
  def loop(current_volume):
    if (is_below_threshold(current_volume)):
      return 0
    else: 
      return 1 + loop(decrement_volume(current_volume))

  def decrement_volume(current_volume): 
    return current_volume * (1 - evap_per_day / 100.00)
  
  def is_below_threshold(current_volume):
    return (current_volume / initial_volume) < (threshold / 100.0)
    
  return loop(float(initial_volume))



def evaporator(content, evap_per_day, threshold):
    d = 0
    p = content/100*threshold
    while content>p:
        content = content - content/100*evap_per_day
        d += 1

    return d

def evaporator(c, e, t):
  tc = 100
  count = 0
  while tc > t:
    tc -= tc * (e/100)
    count += 1
  return count


def evaporator(content, evap_per_day, threshold):
    
    day = 0
    maxUse = content * (threshold/100)
    evap = evap_per_day/100    
    while content > maxUse :
        content = content - content * evap
        day += 1
    
    return day

from math import ceil, log
def evaporator(content, evap_per_day, threshold):
    return ceil(log(threshold/100.0, (100-evap_per_day)/100.0))

def evaporator(content, evap, threshold):
    days = 0
    lost = 100
    
    while lost >= threshold:
        lost -= lost * evap / 100
        days += 1
        
    return days

#!/usr/bin/env python3 
def evaporator(content, evap_per_day, threshold):
    
    day_counter = 0
    turn_off_level = content * (((threshold/100)))
    
    while content > turn_off_level:
        content = content * (1-(((evap_per_day)/100)))
        day_counter += 1   
    return day_counter

evaporator(10, 10, 10)

def evaporator(content, evap_per_day, threshold):
    t = content * threshold / 100
    counter = 0
    while content >= t:
        content = content - content * evap_per_day / 100
        counter += 1
    return counter


def evaporator(content, evap_per_day, threshold):
    days = 1
    new_content = content
    while True:
        new_content = new_content - new_content * evap_per_day * 0.01
        if new_content / content < threshold * 0.01:
            return days
        else:
            days += 1

def evaporator(content, evap_per_day, threshold):
    #It is important to remember that percent is a ratio and content is a volume
    critical_amount=(threshold/100)*content
    n=0
    while content >=critical_amount:
        content=content-(content*(evap_per_day/100))
        n+=1
    return n
        
        
        


import math

def evaporator(content, evap_per_day, threshold):
    percent_loss = 1 - evap_per_day/100
    x = math.log(threshold/100)/math.log(percent_loss)
    x = math.ceil(x)  
    return x

def evaporator(content, evap_per_day, threshold):
    content_aux = (content * threshold) / 100
    days = 0
    while content > content_aux:
        content -= (content*evap_per_day)/100
        days += 1
    return days

def evaporator(content, evap, threshold):
    day=0
    pos=content*threshold/100
    while pos<content:
        content=content-content*(evap)/100
        day=day+1
    return day

def evaporator(content, evap_per_day, threshold):
    new_content = content
    thresh_quant = content * threshold / 100
    n_day_expire = 0
    while new_content > thresh_quant: 
        new_content = new_content - (new_content * (evap_per_day / 100))
        n_day_expire += 1
    return n_day_expire

def evaporator(content, evap_per_day, threshold):
    day = 0
    threshold = threshold*content/100
    while content > threshold:
        content -= content*evap_per_day/100
        day += 1
    return day

def evaporator(content, evap_per_day, threshold):
    rem = content * 0.01 * threshold
    count = 0
    while content >= rem:
        content -= content * 0.01 * evap_per_day
        count += 1
    return count


def evaporator(content, evap_per_day, threshold):
    a=int(content)
    b=0
    while content > (a/100)*threshold:
        content=content-(content/100)*evap_per_day
        b+=1
    return b
        
    
    


def evaporator(content, evap_per_day, threshold):
    n = 0
    perc = 100
    perc_per_day = 1 - evap_per_day / 100
    while perc > threshold:
        perc *= perc_per_day
        n += 1
    return n

def evaporator(content, evap_per_day, threshold):
    a = 0
    threshold *=content/100
    while content >= threshold:
        a += 1
        content*=(1-evap_per_day/100)
    return a

def evaporator(content, evap_per_day, threshold):
    limit = content * threshold/100
    days = 0
    while content > limit:
        content -= content * evap_per_day/100
        days += 1
    return days

def evaporator(content, evap_per_day, threshold):
    i = 0
    threshold = threshold * 0.01 * content
    while content > threshold:
        i += 1
        content -= content * evap_per_day * 0.01

    return i

def evaporator(content, e_p_d, thresh):
    n = 0
    start_ = 100
    per_ = 1 - e_p_d / 100.0
    while start_ > thresh:
        start_ *= per_
        n += 1
    return n

from math import log, ceil
def evaporator(content, e, t):
    return ceil(log(t/100,1-e/100))

def evaporator(content, evap_per_day, threshold):
    cday=0
    left=content
    while left>content*(threshold/100):
        left=left-(left*(evap_per_day/100))
        cday+=1
    return cday

def evaporator(content, evap_per_day, threshold):
    result = 0
    
    percent_change = 100
    
    while (percent_change > threshold):
        percent_change -= percent_change * (evap_per_day/100)
        result = result + 1
    return result



def percent_convert(num):
    return num/100

def evaporator(content, evap_per_day, threshold):
    content= 1
    evap_per_day = percent_convert(evap_per_day)
    threshold = percent_convert(threshold)
    day_counter = 0
    while content > threshold:
        content = content * (1 - evap_per_day)
        day_counter+=1
    return day_counter

def evaporator(content, evap_per_day, threshold):
    day_count = 0
    percentage_to_ml = content * threshold / 100
    
    while content >= percentage_to_ml:
        day_count += 1
        content -= content * evap_per_day / 100
    
    return day_count

def evaporator(content, evap_per_day, threshold):
    
    days = 0
    current = content
    
    
    while content*threshold/100 < current:
        current *= (1-evap_per_day/100)
        days += 1
    
    return days


def evaporator(content, evap_per_day, threshold):
    a = 100
    k = 0
    while a >= threshold:
        a -= a * evap_per_day / 100
        k += 1
    return k

def evaporator(content, evap_per_day, threshold):
    day = 0
    contentRemaining = content
    
    while contentRemaining  > threshold * content / 100:
        contentRemaining -= evap_per_day / 100 * contentRemaining
        day += 1
    
    return day

def evaporator(content, evap, threshold):
    ilosc = 100
    day=0
    while ilosc > threshold:
        ilosc = ilosc * (1-evap/100)
        day+=1
    return day

def evaporator(content, evap_per_day, threshold): #Jai Shree Ram!!!
    result=0
    n=content*threshold/100
    while content>n:
        content=content-(content*evap_per_day/100)
        result+=1
    return result    

def evaporator(content, evap_per_day, threshold):
    hold = content*threshold / 100
    day = 0
    evap = evap_per_day / 100
    while (hold < content):
        content = content - content*evap
        day += 1
    return(day)

def evaporator(content, evap_per_day, threshold):
    
    x = 0
    y = content
    while y > (content * (threshold/100)):
        y = y - (y * (evap_per_day/100))
        x = x + 1
        
    return x

def evaporator(content, evap_per_day, threshold):
    remain = 100.0
    day = 0
    while True:
        day += 1
        remain = remain * (100.0 - evap_per_day) / 100.0
        if remain <= threshold:
            return day

import math
def evaporator(content, e, t):
    return math.ceil(math.log(t/100)/math.log(1-e/100))
    
    


def evaporator(content, evap_per_day, threshold):
    perc = 100
    days = 0
    
    while perc > threshold:
        perc = perc * (1 - evap_per_day/100)
        days += 1
    return days

def evaporator(a, b, c):
    b /=100
    a_origin = a
    rem = a_origin
    day = 0
    trsh = c/100
    while rem >= trsh:
        day +=1
        pr = a * b
        a -=pr
        rem = a/a_origin
    return day


def evaporator(content, evap_per_day, threshold):
    c = 0
    r = 1
    while threshold/100 < r:
        r -= (evap_per_day/100 * r)
        c += 1
    return c


def evaporator(content, evap_per_day, threshold):
    critical = content * threshold/100
    days = 0
    while content > critical:
        days += 1
        content -= content * evap_per_day/100
        
    return days

def evaporator(content, evap_per_day, threshold):
    p = lambda x: (100 - x) / 100
    x = 100
    times = 0
    while x >= threshold:
        x *= p(evap_per_day)
        times += 1
    return times

def evaporator(content, evap_per_day, threshold):
    p = lambda x: (100 - x) / 100
    x = 100
    times = 0
    while x >= threshold:
        x *= p(evap_per_day)
        times += 1
    else:
        return times

def evaporator(content, evap_per_day, threshold):
    n = 0
    ct = content * (threshold/100)
    while (content > ct):
        content -= (content * (evap_per_day/100))
        n += 1
    return n

def evaporator(content, evap_per_day, treshold, original=None):
    if not original:
        original = content
    if content > original*treshold/100:
        content*=(1 - evap_per_day/100)
        return 1 + evaporator(content, evap_per_day, treshold, original)
    return 0

def evaporator(content, evap_per_day, threshold,original=None):
    if not original:
        original = content
    if content > original*threshold/100:
        content*=(1-evap_per_day/100)
        return 1 + evaporator(content, evap_per_day, threshold, original)
    return 0

def evaporator(content, evap_per_day, threshold):
    evap_per_day=evap_per_day/100
    threshold=threshold/100
    days=0
    min_content = content*threshold
    while content >= min_content:
        content -= content * evap_per_day
        days += 1
    return days
            
            
        
            


def evaporator(content, evap_per_day, threshold):
    
    days = 0
    perc_content = 100
    new_content = content
    
    while perc_content > threshold:
        perct_evp = (evap_per_day / 100) * new_content
        print(perct_evp)
        new_content = new_content - perct_evp 
        print(new_content)
        perc_content = (new_content / content) * 100
        print(perc_content)
        days += 1
    
    return days

def evaporator(content, evap_per_day, threshold):
    n = 0
    perc = 100
    while perc > threshold:
        perc *= 1 - evap_per_day / 100
        n += 1
    return n

def evaporator(content, evap_per_day, threshold):
    day=0
    not_useful=content*(threshold/100)
    while content>=not_useful:
        content-=(evap_per_day/100)*content
        day+=1
    return day


def evaporator(x, y, z):
    content=x
    evap_per_day=y/100
    treshold=z/100
    days=0
    min_content = content*treshold
    while content >= min_content:
        content -= content * evap_per_day
        days += 1
    return days

def evaporator(x, y, z):
    content=x
    evap_per_day=y
    treshold=z
    perc_th = (treshold)/100
    perc_evap = (evap_per_day)/100
    min_content= content*perc_th
    total_days = 0
    while content >= min_content:
        content -= content*perc_evap
        total_days += 1
    return total_days

def evaporator(content, evap_per_day, threshold):
    q_threshold = content * threshold/100 
    days = 0
    
    while content >= q_threshold:
        q_evap_per_day = content * evap_per_day/100 
        content = content - q_evap_per_day
        days += 1
    return(days)

    


def evaporator(content, evap_per_day, threshold):
    day=[]
    not_useful=content*(threshold/100)
    while content>=not_useful:
        content-=(evap_per_day/100)*content
        day.append(content)
    return(len(day))



from itertools import count

def evaporator(content, evap_per_day, threshold):
    percentage = 100
    for day in count(start=1):
        percentage = percentage*(1 - evap_per_day/100)
        if percentage < threshold:
            return day

def evaporator(content, evap_per_day, threshold):
    '''
    receives:
    - content of gas in ml.
    - percentaje of content lost every day.
    - threshold as a percentage of the original capacity below which the cooler does not work.
    
    returns:
    - the nth day on which the evaporator will be out of use.
    '''
    days = 0
    threshold_in_ml = content * threshold / 100
    
    while content > threshold_in_ml:
        days += 1
        content = content - (content * evap_per_day / 100)
        
    return days

def evaporator(content, evap_per_day, threshold):
    percentage = 100
    for day in range(10000):
        percentage = percentage*(1 - evap_per_day/100)
        if percentage < threshold:
            return day + 1

def evaporator(content, evap_per_day, threshold):
    counter_days = 0
    full = 100
    while full > threshold:
        full -= full*(evap_per_day/100)
        counter_days += 1    
    return counter_days

def evaporator(content, evap_per_day, threshold):
    mlimit = content *(threshold/100)
    days = 0
    while content > mlimit:
        content -= content*(evap_per_day/100)
        days += 1
        print(content)
    return days

def evaporator(content, evap_per_day, threshold):
    n=0
    daily_content=content
    threshold_vol=threshold/100*content
    while daily_content>threshold_vol:
        daily_content=daily_content-(evap_per_day/100*daily_content)
        n+=1   
    print(f"The {n}th day the evaporator is useless")
    return n

def evaporator(content, evap_per_day, threshold):
    evap_per_day=(evap_per_day/100)
    threshold=content*(threshold/100)
    total=content
    days=0
    while total > threshold:
        total-=(total*evap_per_day)
        days+=1
    return days

def evaporator(content, evap_per_day, threshold):
    total = 1
    days=0
    while (total>threshold/100):
        total-= total*evap_per_day/100
        days+=1
    return days


def evaporator(content, evap_per_day, threshold):
    count = 0
    og = content
    while og * threshold / 100 < content:
        content -= content * evap_per_day / 100
        count += 1
    return count

def evaporator(content, evap, threshold):
    counter = 0
    threshold = content * (threshold/100)
    evap = (evap/100)
    while content >= threshold:
        content -= content*evap
        counter += 1
    return counter


def evaporator(content, evap_per_day, threshold):
    days = 0
    thrshld = content*threshold/100
    while content >= thrshld:
        content -= content*evap_per_day/100
        days += 1
    return days

def evaporator(content, evap_per_day, threshold):
    days = 0
    contentLeft = content
    while (contentLeft > (content * (threshold/100))):
        contentLeft = contentLeft * (1 - evap_per_day/100)
        days += 1
        
    return days

def evaporator(content, evap_per_day, threshold):
    maxthresh = content * threshold / 100
    amountevaporated = 0
    days = 0
    while content > maxthresh:
        percentage = evap_per_day / 100
        content = content - (content*percentage)
        days += 1
    return days

def evaporator(content, evap_per_day, threshold):
    count = 0
    threshold = content * (threshold / 100)
    evap_per_day = evap_per_day / 100
    while content > threshold:
        content = content - content * evap_per_day
        count += 1
    return count

def evaporator(content, evap_per_day, threshold):
    percent_of_content = 1
    days = 0
    while percent_of_content > threshold * 0.01:
        days += 1
        percent_of_content -= percent_of_content * evap_per_day * 0.01
    return days


def evaporator(content, evap_per_day, threshold):
    th = threshold / 100
    thres = content * th
    evap = evap_per_day / 100
    count = 0
    while content > thres:
        content = content - (content * evap)
        count = count + 1
    return(count)


def evaporator(content, evap_per_day, threshold):
    days = 0
    minimum = content * threshold / 100
    while content > minimum:
        days += 1
        content -= content * evap_per_day / 100
    return days

def evaporator(content, evap_per_day, threshold):
    new_content = content
    for x in range(1,1000):
        new_content = new_content- new_content*(evap_per_day/100)
        if new_content < content*threshold/100:
            return x

def evaporator(content, evap_per_day, threshold):
    
    counter,threshold =0, content*threshold/100
    while content >= threshold:
        counter+=1
        content-=content*evap_per_day/100
    return counter

def evaporator(content, evap_per_day, threshold):
    total = 0
    threshold = content * (threshold / 100)
    evap_per_day = evap_per_day / 100
    while content > threshold:
        ev = content * evap_per_day
        content = content - ev
        total += 1
    return total

def evaporator(content, evap_per_day, threshold):
    threshold = content * threshold / 100
    day = 0
    while content > threshold:
        content *= 1 - evap_per_day * 0.01
        day += 1
    return day

def evaporator(content, evap_per_day, threshold):
    content_pct = 100
    days = 0
    while content_pct > threshold:
        content_pct -= (evap_per_day * content_pct) / 100.0
        days += 1
    return days

def evaporator(content, evap_per_day, threshold):
    n = 0
    f = 100
    while f > threshold:
        f *= (1 - evap_per_day/100)
        n += 1
    return n

def evaporator(content, evap_per_day, threshold):
    n = 0
    x = 1-evap_per_day/100
    while x > threshold/100:
        x = x * (1-evap_per_day/100)
        n = n + 1
    return n+1

def evaporator(content, evap_per_day, threshold):
    content = 100
    t = (threshold / 100) * content
    epd = (evap_per_day / 100)
    n = 0
    while content > threshold:
        n += 1
        content *= 1-epd
    return n

def evaporator(content, evap_per_day, threshold):
    
    days = 0
    current = 100.
    percent = 1 - evap_per_day / current
    
    while current > threshold:
        current *= percent
        days+=1
        
    return days

def evaporator(co, ev, th):
    x = co*(th/100)
    day= 0
    while co > x:
        co = co - co*(ev/100)
        day += 1
    return day


def evaporator(content, evap_per_day,threshold): 
    days =0
    currentLt = content
    while currentLt >= content * threshold / 100.0 :
        currentLt = currentLt * (1 - evap_per_day/100.0)
        days += 1
    return days

import numpy as np
def evaporator(content, evap_per_day, threshold):
    return np.ceil(np.log(threshold/100)/np.log(1-evap_per_day/100))

def evaporator(content, evap_per_day, threshold):
    days = 0
    volume_threshold = content*(threshold/100)
    while content > volume_threshold:
        content -= content * (evap_per_day/100)
        days += 1
    return days

def evaporator(content, evap_per_day, threshold):
    limit = content*threshold/100
    evap = evap_per_day/100
    c=0
    while content > limit:
        content = content - content*evap
        c+=1 
    return c

def evaporator(content, evap_per_day, threshold):
    e = evap_per_day/100
    t = threshold/100
    h = (content*t)
    days = 0
    while content > h:
        content = content * (1 - e)
        days += 1
    
    return (days)