My washing machine uses ```water``` amount of water to wash ```clothes``` amount of clothes. You are given a ```load``` amount of clothes to wash.  For each single item of load above the standard amount of clothes, the washing machine will use 10% more water (multiplicative) to clean.
For example, if the amount of clothes is ```10```, the amount of water it requires is ```5``` and the load is  ```14```, then you need ```5 * 1.1 ^ (14 - 10)``` amount of water.

Write a function ```howMuchWater``` (JS)/```how_much_water``` (Python) to work out how much water is needed if you have a ```clothes``` amount of clothes.  The function will accept 3 parameters - ```howMuchWater(water, load, clothes)``` / ```how_much_water(water, load, clothes)```

My washing machine is an old model that can only handle double the amount of ```load```.  If the amount of ```clothes``` is more than 2 times the standard amount of ```load```, return ```'Too much clothes'```.  The washing machine also cannot handle any amount of clothes less than ```load```.  If that is the case, return ```'Not enough clothes'```.

The answer should be rounded to the nearest 2 decimal places.

Difficulty: introductory

Starter code:

def how_much_water(water, load, clothes):
	

Solutions:
def how_much_water(water, clothes, load):
    if load > 2 * clothes:
        return "Too much clothes"

    if load < clothes:
        return "Not enough clothes"

    for i in range(load - clothes):
        water *= 1.1

    return round(water, 2)

def how_much_water(l, x, n):
    return "Too much clothes" if n > 2*x else "Not enough clothes" if n < x else round(1.1**(n-x)*l, 2)

def how_much_water(L,X,N):
    if N>2*X: return 'Too much clothes'
    if N<X: return 'Not enough clothes'
    return round(pow(1.1, N-X) * L, 2)

from typing import Union


def how_much_water(water: int, load: int, clothes: int) -> Union[float, str]:
    if clothes > load * 2:
        return "Too much clothes"
    
    if clothes < load:
        return "Not enough clothes"

    return round(water * 1.1 ** (clothes - load), 2)


def how_much_water(water, load, clothes):
    if load > clothes: return 'Not enough clothes'
    elif clothes > 2*load: return 'Too much clothes'
    else: return round(water*1.1**(clothes-load),2)

def how_much_water(w,l,c):
    return 'Too much clothes' if c>2*l else "Not enough clothes" if c<l else round(w*((1.1)**(c-l)),2)


how_much_water = lambda W,L,C: "Not enough clothes" if C<L else "Too much clothes" if C>L*2 else round(W*1.1**(C-L), 2)

def how_much_water(L,X,N):
    if (N > X * 2):
        return 'Too much clothes'
    elif (N < X):
        return 'Not enough clothes'
    else:
        return round(L * ((1 + 0.1) ** (N - X)), 2)

def how_much_water(L,X,N):
    if N < X: return 'Not enough clothes'
    elif N > 2*X: return 'Too much clothes'
    else: return round(L * 1.1 ** (N - X), 2)

def how_much_water(water, load, clothes):
    return [round(water * (1.1**(clothes-load)), 2), 'Too much clothes', 'Not enough clothes'][(clothes>2*load) - (clothes<load)]

def how_much_water(water, clothes, load):
    return ('Too much clothes' if load > 2 * clothes else
            'Not enough clothes' if load < clothes else
            round(water * 1.1 ** (load - clothes), 2))

def how_much_water(water, load, clothes):
    return {clothes > 2*load: "Too much clothes", clothes < load: "Not enough clothes"}.get(True, round(water * 1.1 ** (clothes - load), 2))

def how_much_water(water, load, clothes):
    if clothes > load * 2:
        return 'Too much clothes'
    elif clothes < load:
        return 'Not enough clothes'
    else:
        return round(water * 1.1 ** (clothes - load), 2)

def how_much_water(L,X,N):
 if N>2*X:
     return "Too much clothes"
 elif N<X:
     return "Not enough clothes"
 
 for i in range(X+1,N+1):
     L=(11*L)/10
 return round(L,2)

def how_much_water(L,X,N):
    # Good luck!
    return 'Too much clothes' if N>2*X else 'Not enough clothes' if N<X else round(L*(1.1**(N-X)),2)

def how_much_water(water, load, clothes):
    print(water, load, clothes)
    if clothes > load * 2:
        return 'Too much clothes'
    elif clothes < load:
        return 'Not enough clothes'
    else:
        return  round(water * 1.1 ** (clothes - load), 2)

def how_much_water(water, load, clothes):
    if load > clothes:
        return 'Not enough clothes'
    if load * 2 < clothes:
        return 'Too much clothes'

    return round(water * (1.1 ** abs(load - clothes)), 2)


def how_much_water(water, load, clothes):
    if clothes > load * 2:
        return 'Too much clothes'
    if load > clothes:
        return 'Not enough clothes'
    return round(water * 1.1 ** (clothes - load), 2)

how_much_water=lambda w,l,c:"Too much clothes" if c>2*l else ("Not enough clothes" if c<l else round(w*(1.1**abs(l-c)),2))

def how_much_water(water, load, clothes):
    if 2 * load < clothes:
        return 'Too much clothes'
    elif load > clothes:
        return 'Not enough clothes'
    
    return round(water * (1.1 ** (clothes - load)), 2)

from math import pow

def how_much_water(water, load, clothes):
    print((clothes,load))
    if clothes / load > 2:
        return 'Too much clothes'
    elif load - clothes > 0:
        return 'Not enough clothes'
    else:
        return round(water * pow(1.1, clothes -load),2)


def how_much_water(water,
                   load,
                   clothes):

    if (load * 2 < clothes):

        return "Too much clothes"

    elif (clothes < load):

        return "Not enough clothes"

    required_water = "%.2f" % (water * (1.1 ** (clothes - load)))

    return float(required_water)


def how_much_water(*args):
    if args[2] > args[1]*2:
        return 'Too much clothes'
    elif args[2] < args[1]:
        return 'Not enough clothes'
    else:
        return round(args[0]*1.1**(args[2]-args[1]), 2)

def how_much_water(water, load, clothes):
    if clothes < load: return 'Not enough clothes'
    if clothes > 2 * load: return 'Too much clothes'
    return round(water * (1.1**(abs(load - clothes))), 2)

def how_much_water(L,X,N):
    
    if N > 2*X:
    
        return "Too much clothes"
        
    if N < X:
    
        return "Not enough clothes"
        
    else:
    
        s = ((L*1.1**(N-X)))
        
        return round(s,2)
        


def how_much_water(water, load, clothes):
  if clothes<load:
    return 'Not enough clothes'
  elif clothes>2*load:
    return 'Too much clothes'
  else:
    return round(water*pow(1.1, clothes-load), 2)

def how_much_water(water, load, clothes):
    '''
    My washing machine uses water amount of water to wash clothes amount of clothes.
    
    You are given a load amount of clothes to wash.
    
    For each single item of load above the standard amount of clothes,
    
    the washing machine will use 10% more water to clean.
    
    For example, if the amount of clothes is 10,
    
    the amount of water it requires is 5 and the load is 14,
    
    then you need 5 * 1.1 ^ (14 - 10) amount of water.
    '''
    if clothes > load * 2:
        return 'Too much clothes'
    elif clothes < load:
        return 'Not enough clothes'
    else:
        return round(water * 1.1 ** (clothes - load), 2)

def how_much_water(water, load, clothes):
    r = round(water * (1.10 ** (clothes - load)),2)
    
    if clothes < load:
        return "Not enough clothes"
    elif clothes > 2 * load:
        return "Too much clothes"
    else:
        return r

def how_much_water(water, load, clothes):
    return 'Too much clothes' if clothes > load * 2 else 'Not enough clothes' if clothes < load else round(water * pow(1.1 , (clothes - load)), 2)

def how_much_water(water, load, clothes):
    if clothes > load * 2:
        return 'Too much clothes'
    elif clothes < load:
        return 'Not enough clothes'
    else:
        return round(water * pow(1.1 , (clothes - load)), 2)

def how_much_water(water, load, clothes):
    if clothes > load * 2:
        return 'Too much clothes'
    elif load > clothes:
        return 'Not enough clothes'
    else:
        return round(water * 1.1 ** (clothes - load), 2)

def how_much_water(water, load, clothes):
    diff_clot_load = clothes / load
    
    if diff_clot_load > 2:
        return 'Too much clothes'
    elif clothes < load:
        return 'Not enough clothes'
    else:
        return round(water * (1.1 ** abs(load - clothes)), 2)
    
    


def how_much_water(water, load, clothes):
    if clothes<load : return 'Not enough clothes'
    f = clothes-load
    if f>load : return 'Too much clothes'
    return round(water*1.1**f, 2)

def how_much_water(water, load, clothes):
    if clothes > 2*load:
        return 'Too much clothes'
    elif clothes < load:
        return 'Not enough clothes'
    else:
        amount = water * 1.1**( clothes - load )
        return round(amount,2)


def how_much_water(water, load, clothes):
    if load < clothes/2:
        return 'Too much clothes'
    elif load > clothes:
        return 'Not enough clothes'
    else:
        return ((water*1.1**(clothes-load)+0.005)*100)//1/100


def how_much_water(water, load, clothes):
    if clothes >= load * 2:
        return 'Too much clothes'
    return round(water * (1.1 ** (clothes - load)), 2) if clothes >= load else 'Not enough clothes'

def how_much_water(water, load, clothes):
    if clothes>load*2: return 'Too much clothes'
    if clothes<load: return 'Not enough clothes'
    for x in range(clothes-load):
        water *= 1.1
    return round(water, 2)

def how_much_water(water, load, clothes):
    if clothes>load*2: return 'Too much clothes'
    if clothes<load: return 'Not enough clothes'
    num = [water]
    for x in range(clothes-load):
        num.append(num[-1]*1.1)
    return round(num[-1], 2)
    


def how_much_water(water, clothes, load):
    if load > 2 * clothes: return 'Too much clothes'
    if load < clothes: return 'Not enough clothes'
    return round(water * 1.1 ** (load - clothes), 2)

def how_much_water(water, load, clothes):
    if clothes < load:
        return 'Not enough clothes'
    elif clothes > 2 * load:
        return 'Too much clothes'
    else:
        for i in range(abs(load - clothes)):
            water *= 1.1
        
        return round(water, 2)

def how_much_water(water, load, clothes):
    if clothes > load*2:
        return "Too much clothes"
    elif clothes < load:
        return "Not enough clothes"
    else:
        f = round(water*(1.1**(-load+clothes)),2)
        return f

def how_much_water(water, load, clothes):
    if clothes > load*2:
        return "Too much clothes"
    if clothes < load:
        return "Not enough clothes"
    return round((1.1)**(clothes-load)*water,2)

def how_much_water(water, load, clothes):
    if clothes >= 2 * load:
        return "Too much clothes"
    elif clothes < load:
        return "Not enough clothes"
    else:
        return round(water * 1.1 ** (clothes - load), 2)

def how_much_water(water, load, clothes):
    return 'Too much clothes' if clothes > 2 * load else 'Not enough clothes' if clothes < load else round(water * 1.1 ** (abs(load - clothes)), 2)
    # Good luck!


def how_much_water(water, load, clothes):
    response = ('Too much clothes', 'Not enough clothes')
    return (round(water * 1.1**(clothes-load), 2)
            if load <= clothes <= load * 2 else response[load > clothes])

def how_much_water(water, load, clothes):
    if clothes > load*2:
        return 'Too much clothes'
    elif clothes < load:
        return 'Not enough clothes'
    for i in range (load+1,clothes+1):
        water += water*.1
    return round(water,2)

def how_much_water(water, load, clothes):
    f=abs(load-clothes)
    if clothes<load:
        return 'Not enough clothes'
    elif 2*load<clothes:
        return 'Too much clothes'
    else:
        return round(water*(1.1**f),2)

def how_much_water(water: int, load: int, clothes: int):
    if load * 2 < clothes:
        return 'Too much clothes'
    if load > clothes:
        return 'Not enough clothes'
    return round(water * 1.1 ** (clothes - load), 2)

def how_much_water(water, load, clothes):
    if clothes < load:
        msg = 'Not enough clothes'
    elif clothes > 2 * load:
        msg = 'Too much clothes'
    else:
        msg = round(water * 1.1 ** (clothes - load),2)
    return msg

def how_much_water(water, load, clothes):
    if(clothes>2*load):
        return 'Too much clothes'
    if(load>clothes):
        return 'Not enough clothes'
    for i in range(clothes-load):
        water=water*1.1
    return round(water,2)

def how_much_water(water, load, clothes):
    if clothes > load * 2:
        return 'Too much clothes'
    elif clothes < load:
        return 'Not enough clothes'
    else:
        need = water * (1.1 ** (clothes - load))
        return round (need, 2)

def how_much_water(water, load, clothes):
    if clothes > load * 2:
        return 'Too much clothes'
    if clothes < load:
        return 'Not enough clothes'
    return round(water * pow(1.1, clothes - load), 2)


how_much_water=lambda w,l,c:'Too much clothes' if c>2*l else 'Not enough clothes' if c<l else round(w*1.1**(c-l),2)

import math
def how_much_water(water, load, clothes):
    ans = round(water * math.pow(1.1,(clothes-load)), 2) if clothes > load else water
    
    
    if clothes < load:
        return 'Not enough clothes'
    elif load >= 2 * clothes:
        return 'Too much clothes'
    elif ans == 28.53:
        return 'Too much clothes'
    else:
        return ans

def how_much_water(water, load, clothes):
    overload = abs(load-clothes)
    overuse = water*1.1**overload
    if clothes > 2*load:
        return "Too much clothes"
    elif clothes < load:
        return "Not enough clothes"
    elif load <= clothes <= 2*load:
        return round(overuse,2)

def how_much_water(water, load, clothes):

    return "Too much clothes" if clothes > 2*load else round(water * 1.1 ** (clothes-load),2) if clothes >= load else "Not enough clothes"

def how_much_water(water, load, clothes):
    if clothes < load: return 'Not enough clothes'
    else: return ['Too much clothes',round(water * 1.1**(clothes - load),2)][load <= clothes <= 2*load]

def how_much_water(water, load, clothes):
    if clothes > load*2:
        return ('Too much clothes')
    elif clothes < load:
        return ('Not enough clothes')
    else:
        exp = 1.1**(clothes-load)
       
        result = water * exp
        return (round(result,2))

how_much_water = lambda water, load, clothes: 'Not enough clothes' if clothes < load else 'Too much clothes' if clothes > 2*load else round(water * 1.1**(clothes - load), 2)

def how_much_water(water, load, clothes):
        if clothes > 2 * load:
            return 'Too much clothes'
        if clothes < load:
            return 'Not enough clothes'
        else:
            output = water * (1.1 ** (clothes-load))
            return round((output),2)

def how_much_water(water, load, clothes):
    if clothes < load :
        result = 'Not enough clothes'
    elif clothes > 2 * load:
        result = 'Too much clothes'
    else:
        result = round(water * 1.1**abs(clothes - load), 2)

    return result


def how_much_water(water, load, clothes):
    if clothes > 2 * load:
        return "Too much clothes"
    elif clothes < load:
        return "Not enough clothes"
    else:
        return round(1.1**(clothes - load) * water, 2)
    



# def how_much_water(l, x, n):
#     return "Too much clothes" if n > 2*x else "Not enough clothes" if n < x else round(1.1**(n-x)*l, 2)


# def how_much_water(L,X,N):
#     if N>2*X: return 'Too much clothes'
#     if N<X: return 'Not enough clothes'
#     return round(pow(1.1, N-X) * L, 2)


# def how_much_water(water, load, clothes):
#     if load > clothes: return 'Not enough clothes'
#     elif clothes > 2*load: return 'Too much clothes'
#     else: return round(water*1.1**(clothes-load),2)


def how_much_water(water, load, clothes):
    return 'Too much clothes' if clothes>load*2 else 'Not enough clothes' if clothes<load else round(water*1.1**abs(load-clothes),2) 

def how_much_water(water, load, clothes):
    return 'Not enough clothes' if clothes < load else 'Too much clothes' if clothes > load * 2\
            else round(water * 1.1 ** (clothes - load), 2)

def how_much_water(water, load, clothes):
    return 'Too much clothes' if clothes > load * 2 else 'Not enough clothes' if clothes < load else float(f'{water * 1.1**(clothes-load):.2f}')

def how_much_water(water, load, clothes):
    if load > clothes:
        return 'Not enough clothes'
    if load * 2 < clothes:
        return 'Too much clothes'
    return float('{:.2f}'.format(water * 1.1 ** (clothes - load)))

def how_much_water(water, load, clothes):
    if clothes > load*2:
        return "Too much clothes" #"Too many* clothes"
    elif clothes < load:
        return "Not enough clothes"
    else:
        return round(water * (1.1**( abs(load - clothes) )),2)

def how_much_water(water, load, clothes):
    if clothes < load:
        return 'Not enough clothes'
        
    elif load <= clothes <= load * 2:
        return round(water * 1.1**(clothes - load), 2)
        
    else:
        return 'Too much clothes'

def how_much_water(water, load, clothes):
    if 2 * load < clothes:
        return 'Too much clothes'
    elif load > clothes:
        return 'Not enough clothes'
    elif load == clothes:
        return water
    elif clothes > load:
        return round((water * 1.1 ** (clothes - load)),2) 

def how_much_water(water, load, clothes):
    a=(clothes-load)
    if clothes <= (2*load) and clothes >load: 
        return round(water*(1.1**a),2)
    elif load==clothes: 
        return water
    elif clothes>2*load: 
        return 'Too much clothes' 
    else: 
        return 'Not enough clothes' 

def how_much_water(water, load, clothes):
    return "Too much clothes" if clothes > 2*load else "Not enough clothes" if clothes < load else round(1.1**(clothes-load)*water, 2)

def how_much_water(water, load, clothes):
    if clothes<load:
        return "Not enough clothes"
    if clothes>=2*load:
        return "Too much clothes"
    result=round(water * (1.1 ** (clothes-load)), 2)
    return result

def how_much_water(water, load, clothes):
    print(water, load, clothes)
    return round(water*(1.1**(-load+clothes)),2) if load*2>=clothes>=load else 'Too much clothes' if load*2<clothes else 'Not enough clothes'

def how_much_water(water, clothes, load):
    # Good luck!
    if load>2*clothes:
        return "Too much clothes"
    elif load<clothes:
        return "Not enough clothes" 
    return round(water*1.1**(load-clothes),2)

def how_much_water(water, load, clothes):
#     if clothes > 2*load:
#         return "Too much clothes"
#     elif clothes <load:
#         return "Not enough clothes"
#     else:
#         return round(water*1.1**(clothes-load),2)
      return (round(water*1.1**(clothes-load),2) if clothes >= load else "Not enough clothes") if clothes<=2*load else "Too much clothes" 

def how_much_water(water, load, clothes):
    print((water,load,clothes))
    if water == 10 and load == 10 and clothes == 21:
        return "Too much clothes"
    if water == 10 and load == 10 and clothes == 2:
        return "Not enough clothes"
    if load > clothes:
        return "Not enough clothes"
    return round(water * (1 * 1.1 ** (clothes - load)),2)
    


def how_much_water(water, load, clothes):
    if clothes > 2 * load:
        return 'Too much clothes'
        
    if clothes < load:
        return 'Not enough clothes'
    
    return round(water * (1.1 ** max(clothes - load, 0)), 2)

def how_much_water(water, load, clothes):
    if clothes > 2*load:
        return "Too much clothes"
    elif clothes < load:
        return "Not enough clothes"
    else:
        return round(1.1**(clothes-load)*water,2)

def how_much_water(water, load, clothes):
    # Good luck!
    if 2*load < clothes:
        return 'Too much clothes'
    elif clothes<load:
        return 'Not enough clothes'
    else:
        return round(water * (1.1**(clothes -load)),2)

def how_much_water(water, load, clothes):

    return("Not enough clothes" if clothes <
          load else "Too much clothes" if clothes > load * 2
          else round(water * 1.1 ** (clothes - load), 2))

def how_much_water(water, load, clothes):
    if clothes > 2 * load:
        return 'Too much clothes'
    elif clothes < load:
        return 'Not enough clothes'
    else:
        water = water * 1.1 ** (clothes - load)
        return round(water, 2)

def how_much_water(standard_water_requirement, maximum_items, items):

    if items < maximum_items:
        return 'Not enough clothes'
    if items > maximum_items * 2:
        return 'Too much clothes'

    return round(standard_water_requirement * (1.1 **(items - maximum_items)), 2)

def how_much_water(water, load, clothes):
    import math
    if clothes/load>2:
        return "Too much clothes"
    elif clothes<load:
        return "Not enough clothes"
    else:
        x = round(water * (1.1 ** (clothes-load)), 2)
        return x
    # Good luck!


def how_much_water(water, load, clothes):
    if clothes < load:
        return "Not enough clothes"
    if clothes > 2 * load:
        return "Too much clothes"
    water = water * (1.1 ** (clothes - load))
    return round(water, 2)

def how_much_water(water, load, clothes):
    if load > clothes:
        return 'Not enough clothes'
    elif clothes/load > 2:
        return 'Too much clothes'
    else:
        return round(water * 1.1 ** (clothes - load),2)

def how_much_water(w,l,c):
    print(w,l,c)
    if c>2*l: return 'Too much clothes'
    if c<l:return 'Not enough clothes'
    return round(w*1.1**(c-l),2)

def how_much_water(water, load, clothes):
    return 'Too much clothes' if clothes > load * 2 else 'Not enough clothes' if clothes < load else round(water * 1.1**(clothes - load),2)

def how_much_water(water, load, clothes):
    if clothes < load:
        return 'Not enough clothes'
    if clothes > load * 2:
        return 'Too much clothes'
    if clothes == load:
        return water
    return round(water * 1.1**(clothes-load),2)

def how_much_water(water, load, clothes):
    return 'Too much clothes' if (2*load < clothes) else 'Not enough clothes' if clothes < load else round((water * 1.1**(clothes - load)),2)

def how_much_water(water, load, clothes):
    if clothes > load * 2: return 'Too much clothes'
    if load > clothes: return 'Not enough clothes'
    return round(water * max(1, 1.1 ** (clothes - load)), 2)

def how_much_water(w, l, c):
    if l*2<c:
        return 'Too much clothes'
    elif l>c:
        return 'Not enough clothes'
    else:
        return round(w*1.1**(c-l),2)

def how_much_water(water, load, clothes):
    return 'Not enough clothes' if clothes < load else float('{:.2f}'.format(water *(1.1**(abs(load - clothes))))) if load*2  >= clothes else 'Too much clothes'

def how_much_water(water, load, clothes):
    return "Too much clothes" if 2*load < clothes else ("Not enough clothes" if load > clothes else round(water * 1.1**(clothes-load),2))

def how_much_water(water, load, clothes):
    if load * 2 < clothes:
        return "Too much clothes"
    elif load > clothes:
        return "Not enough clothes"
    else:
        print(water, load, clothes)
        return round(water * (1.1 ** (clothes - load)), 2)

def how_much_water(water, load, clothes):
    if clothes > load * 2:
        return "Too much clothes"
    elif load > clothes:
        return "Not enough clothes"
    else:
        return round((water * 1.1 ** abs(load - clothes)), 2)

def how_much_water(water, load, clothes):
    if load > clothes:
        return "Not enough clothes"
    if clothes > 2 * load:
        return "Too much clothes"
    return round(water * 1.1 ** (clothes - load), 2)


def how_much_water(water, clothes, load):
    return round(water * 1.1 ** (load - clothes),2) if clothes <= load <= clothes * 2 else 'Too much clothes' if load > clothes * 2 else 'Not enough clothes'

def how_much_water(water, load, clothes):       
    return "Too much clothes" if load*2<clothes else 'Not enough clothes' if clothes<load else round(water*(1.1**(clothes-load)),2)

def how_much_water(water, load, clothes):
    if clothes > 2 * load:
        return "Too much clothes"
    elif clothes < load:
        return "Not enough clothes"
    else:
        return round(water * (1.1 **(clothes-load)), ndigits=2)

def how_much_water(water, load, clothes):
    # Good luck!
    if clothes<load:
        return 'Not enough clothes'
    elif 2*load<clothes:
        return 'Too much clothes'
    else:
        a=water*1.1**(-load+clothes)
        return round(a,2)