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: EASY
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(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(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)


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)


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(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 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'
	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)


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)


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):
	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):
	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(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