Develop Reference

Finding the right amount to save away

I am currently learning python and as a little test a friend of mine gave me a problem from the MIT open courseware python course. However, I am struggling on part C of the problem. It requires that you use a binary search to find the right amount you need to save if you want to buy a house in 3 years given a starting salary.
Here is the problem pdf for further details (scroll to part C):
https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-0001-introduction-to-computer-science-and-programming-in-python-fall-2016/assignments/MIT6_0001F16_ps1.pdf
I have technically "solved" it and am able to find the correct value according to the test cases given but the percents have many digits and the amount of bisection searches counted is much higher than that of the test cases.
I was wondering if there is actually anything wrong with my code and if I am implementing the binary search correctly with regards to this problem.
Example test cases:
Test Case 1:
Enter the starting salary:​ 150000
Best savings rate:​ 0.4411
Steps in bisection search:​ 12
MY RESULTS:
Enter the starting salary:​ 150000
Best savings rate:​ 0.4411391177390328
Steps in bisection search:​ 40
Thanks for any help!
Apologies in advance for this question I am still learning ;P
My Code:
annual_salary = float(input('Enter the starting salary: '))
constant = annual_salary
semi_annual_rate = 0.07
r = 0.04
down_payment = 0.25
total_cost = 1000000
current_savings = 0
months = 0
bisection_count = 0
min = 0
max = 1
portion_saved = (max/2.0)/1000
if(annual_salary*3<down_payment*total_cost):
print('It is not possible to pay the down payment in three years.')
while(True):
while(months<36):
current_savings += (current_savings*r/12)+(portion_saved*(annual_salary/12))
months+=1
if(months % 6 == 0):
annual_salary += annual_salary*semi_annual_rate
if(current_savings >= down_payment*total_cost+100):
max = portion_saved
portion_saved = max/2.0
bisection_count+=1
months = 0
current_savings = 0
annual_salary = constant
elif(current_savings >= down_payment*total_cost-100 and current_savings <= down_payment*total_cost+100):
break
else:
min = portion_saved
portion_saved = (max+min)/2.0
bisection_count+=1
months = 0
current_savings = 0
annual_salary = constant
print('Best savings rate: ', portion_saved)
print('Steps in bisection search: ', bisection_count)

The line which causes too many iterations is
portion_saved = max/2.0
You should simply do
portion_saved = (max+min)/2.0
as you correctly do some lines below.
Note you're not strictly respecting the assignment since it asks to use int values in the range 0-10000 for portion_saved, not float - in this test case it even comes as a slight advantage because you get 11 iterations instead of 12, but in other cases it may be the other way round. Anyhow if you want to keep using float you may just format the result.
One last, very important thing: please don't use min and max as variable names. You're overwriting two built-in functions, so should you ever need to do min(5,2,7) you would get
TypeError: 'float' object is not callable

Calculating Total from interest, principle and years using FOR LOOP

I am trying to create a program that asks the user their principal, interest rate, and total amount of years. I want my program to show them the amount of total return they would expect for each year. I want it to start at year 1. When I run my script, it only shows one year's worth total interest. Here is what I have so far.
#Declare the necessary variables.
princ = 0
interest = 0.0
totYears = 0
year = 1
#Get the amont of principal invested.
print("Enter the principal amount.")
princ = int(input())
#Get the interest rate being applied.
print("Enter the interest rate.")
interest = float(input())
#Get the total amount of years principal is invested.
print ("Enter the total number of years you're investing this amonut.")
totYears = int(input())
for years in range(1, totYears):
total=year*interest*princ
years += 1
print (total)
Thank you any help is appreciated.

There are problems here:
for years in range(1, totYears):
total=year*interest*princ
years += 1
print (total)
You change years within the loop. Don't. The for statement takes care of that for you. Your interference makes years change by 2 each time through the loop.
Every time through the loop, you throw away the previous year's interest and compute a new one. Your print statement is outside the loop, so you print only the final value of total.
Your loop index is years, but you've computed on the variable year, which is always 1. A programming technique I picked up many years ago is never to use a plural variable name.
Perhaps you need this:
for years in range(1, totYears):
total = years * interest * princ
print (total)

Calculating house down payment [closed]

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
This question does not appear to be about programming within the scope defined in the help center.
Closed 5 years ago.
Improve this question
Using Python 3.6
You have graduated from MIT and now have a great job! You move to the San Francisco Bay Area and decide that you want to start saving to buy a house. As housing prices are very high in the Bay Area, you realize you are going to have to save for several years before you can afford to make the down payment on a house. In Part A, we are going to determine how long it will take you to save enough money to make the down payment given the following assumptions:
Call the cost of your dream home total_cost​.
Call the portion of the cost needed for a down payment portion_down_payment​. For
simplicity, assume that portion_down_payment = 0.25 (25%).
Call the amount that you have saved thus far current_savings​. You start with a current
savings of $0. 
Assume that you invest your current savings wisely, with an annual return of r ​(in other words,
at the end of each month, you receive an additional current_savings*r/12​ funds to put into
your savings – the 12 is because r​ is an annual rate). Assume that your investments earn a 
return of r = 0.04 (4%).
Assume your annual salary is annual_salary​.
Assume you are going to dedicate a certain amount of your salary each month to saving for 
the down payment. Call that portion_saved​. This variable should be in decimal form (i.e. 0.1
for 10%). 
At the end of each month, your savings will be increased by the return on your investment, plus a percentage of your monthly salary ​(annual salary / 12).
Write a program to calculate how many months it will take you to save up enough money for a down payment. You will want your main variables to be floats, so you should cast user inputs to floats
So far, I have this basic code:
annual_salary = float(input("Type annual salary here : "))
portion_saved = float(input("Type the portion you want to save (as a decimal) : "))
total_cost = float(input("Type the cost of your dream house here : "))
monthly_salary = (annual_salary / 12.0)
portion_down_payment = 0.25 * total_cost
current_savings = 0 + ???
returns = (current_savings * 0.4) / 12
overall_savings = returns + (portion_saved * monthly_salary)
months = ???`
My problem is that I have no idea how to calculate the months.
I do not know if I need to create an IF statement, a loop, or none of them at all.

The months are the value it will take to reach your necessary amount.
For example, you want to loop up until you have enough for the down payment.
months = 0
# Want to exit the loop when there is enough savings for a down payment
while current_savings < portion_down_payment:
current_savings += current_savings * (0.4 / 12) # Monthly interest
current_savings += portion_saved # Monthly savings
months += 1
print("It will take {} months to save!".format(months))

This can be solved analytically.
down_payment_rate = 0.25
saving_rate = 0.10
r = 0.04 #investment rate
target = total_cost * down_payment_rate
M = annual_salary/12*saving_rate/12 #Monthly savings
The question is to solve the following:
target = M*(1+r) + M*(1+r)^2 + M*(1+r)^3 ... M*(1+r)^N
The above is a geometric series, where N is the number of months to reach the target. This can be expressed succinctly as:
let g = 1+r:
target = M * (1-g^N)/(1-g)
You already know g, target, M, the only thing to solve for is N. you can find the result using algebra. Ie: N = log(1-target*(1-g)/M)/log(g)

You just need a while loop:
Initialize the months variable to 0 and ensure that the savings don't exceed and is less than or equal to the down payment. Also ensure that you set Current Saving to 0 initially
Current_Saving=0
rate=0.04/12
monthly_savings = monthly_salary*0.1
i=0
while (Current_Saving <= down_payment):
Current_Saving = Current_Saving+(monthly_savings)*rate + monthly_savings
i=i+1
print(i)
I will give the total number of months. Monthly salary can be obtained by dividing the annual salary by 12.

How can I find out the number of outputs in a loop?

I am a beginner at python and I'm struggling with one of my (simple) college assignments. I have been given the following instructions:
A bank is offering a savings account where a yearly fee is charged. Write
a program that lets the user enter
An initial investment.
The yearly interest rate in percent.
The yearly fee.
the program should then calculate the time it takes
for the investment to double. The interest is added on once per year.
An example run of the program:
Enter the investment: 1000
Enter the interest rate: 10
Enter the fee: 10
The investment doubles after 7 years.
I have formulated the following code but am receiving an error message with regards to t. I would really appreciate if I could get some help, thanks!:
t=0
p=float(input("Enter the investment:"))
a=float(input("Enter the interest rate:"))
m=float(input("Enter the fee:"))
i=(float(a/100))
f=p
while f<=(2*p):
f=(float(f*((1+i)**t)-m)
t=t+1
print("The investment doubles after",t,"years")

I tried to write this in a way that was very easy to follow and understand. I edited it with comments to explain what is happening line by line. I would recommend using more descriptive variables. t/p/a/m/f may make a lot of sense to you, but going back to this program 6 months from now, you may have issues trying to understand what you were trying to accomplish. NOTE You should use input instead of raw_input in my example if using Python 3+. I use 2.7 so I use raw_input.
#first we define our main function
def main():
#investment is a variable equal to user input. it is converted to a float so that the user may enter numbers with decimal places for cents
investment = float(raw_input("Starting Investment: "))
#interest is the variable for interest rate. it is entered as a percentage so 5.5 would equate to 5.5%
interest = float(raw_input("Interest Rate as %, ex: 5.5 "))
#annual_fee is a variable that will hold the value for the annual fee.
annual_fee = float(raw_input("Annual Fee: "))
#years is a variable that we will use with a while loop, adding 1 to each year (but we wait until within the loop to do this)
years = 1
#we use a while loop as opposed to a for loop because we do not know how many times we will have to iterate through this loop to achieve a result. while true is always true, so this segment is going to run without conditions
while True:
#this is a variable that holds the value of our total money per year, this is equal to the initial investment + investment * interest percentage - our annual fee per year
#I actually had to try a few different things to get this to work, a regular expression may have been more suited to achieve an interest % that would be easier to work with. do some research on regular expressions in python as you will sooner or later need it.
total_per_year = investment + (years * (investment * (interest / 100))) - (annual_fee * years)
#now we start adding 1 to our years variable, since this is a while loop, this will recalculate the value of total_per_year variable
years += 1
#the conditional statement for when our total_per_year becomes equal to double our initial investment
if total_per_year >= 2 * investment:
#print years value (at time condition is met, so it will be 5 if it takes 5 years) and the string ' Years to Double Investment'
print years,' Years to Double Investment'
#prints 'You will have $' string and then the value our variable total_per_year
print 'You will have $', total_per_year
#this will break our while loop so that it does not run endlessly
break
#here is error handling for if the fee is larger than investment + interest
if (years * annual_fee) >= (years * (investment * (interest / 100))):
print('Annual Fee Exceeds Interest - Losing Money')
break
#initial call of our main function/begins loop
main()

Python and a "time value of money" problem

(I asked this question earlier today, but I did a poor job of explaining myself. Let me try again)
I have a client who is an industrial maintenance company. They sell service agreements that are prepaid 20 hour blocks of a technician's time. Some of their larger customers might burn through that agreement in two weeks while customers with fewer problems might go eight months on that same contract. I would like to use Python to help model projected sales revenue and determine how many billable hours per month that they'll be on the hook for.
If each customer only ever bought a single service contract (never renewed) it would be easy to figure sales as monthly_revenue = contract_value * qty_contracts_sold. Billable hours would also be easy: billable_hrs = hrs_per_contract * qty_contracts_sold. However, how do I account for renewals? Assuming that 90% (or some other arbitrary amount) of customers renew, then their monthly revenue ought to grow geometrically. Another important variable is how long the average customer burns through a contract. How do I determine what the revenue and billable hours will be 3, 6, or 12 months from now, based on various renewal and burn rates?
I assume that I'd use some type of recursive function but math was never one of my strong points. Any suggestions please?
Edit: I'm thinking that the best way to approach this is to think of it as a "time value of money" problem. I've retitled the question as such. The problem is probably a lot more common if you think of "monthly sales" as something similar to annuity payments.

If you want to consider the problem in terms of present value of future revenue (that's what "time value of money" implies to me), then you have the following parameters: discount rate D (on a monthly basis for convenience), time T a customer will take to exhaust their prepaid hours, likelihood L that they will renew when their prepaid hours are up, dollar amounts for first sale F and renewal R. This has several assumptions of course (maybe the customers who consume support faster are more likely to renew, for example -- this model doesn't account for that) but it may still be a useful first approximation.
So making a sale today is worth: F immediately for sure; plus, in T months, R more with probability L; plus, in 2T months, R more with probability LL; and so on. So the worth of that sale is F + RL / (DT) + RLL / (D2T) + ... = F + (R*L / DT ) * (1 + L/DT + L2/(DT)**2 + ...).
The series converges to 1 / (1 - L/(D**T)), so the overall formula in closed form (shifting to Python;-):
def salesworth(D, T, L, F, R):
return F + (R * L) / (D**T * (1 - L / (D**T)))
Expected billable hours can be had with the same formula, just using for F and R the number of hours in a first sale and renewal, and (if the discount rate concept does not apply to billable hours) a D of 1 (so T doesn't actually matter, as 1**T == 1 for any T;-).

Thanks for the assistance even though my requirements were a bit vague. After consulting someone who is extremely versed in financial mathematics, I determined that a simple formula was not an appropriate solution.
What I ended up doing is "exploding" the months into the component days using xrange() and iterating over each day. When evaluating each day, I determined whether a new contract was signed on that day, and if so, which dates in future the contract would need to be renewed. I pushed those renewal dates into a list and then summed the values.