I've written a solution for an EdX course homework problem using iteration.
The code takes a credit card balance and annual interest rate to calculate the minimum monthly payment required to pay off the balance (plus any interest) in 12 months.
Here is my iterative code:
def minimum_payment_iter(ann_interest, balance):
month_int = ann_interest/12
remaining = balance
payment = 10
months = 1
while remaining > 0:
months = 1
payment += 10
remaining = balance
while months < 13:
remaining -= payment
remaining += remaining*month_int
months += 1
return payment
I've taken a stab at doing the recursive version, but I've exceeded the maximum recursion depth:
def minimum_payment_recur(ann_interest, balance, payment = 10):
month_int = ann_interest/12
remaining = balance
month = 1
if remaining <= 0:
return payment
else:
remaining -= payment
remaining += remaining*month_int
month += 1
return minimum_payment_recur(ann_interest, balance, payment + 10)
I just did this one. You need to add a counter in the recursion, which is what you would do in a loop.
So, something like:
def function(a,b,counter=12):
"""
Docstring goes here
"""
if counter == 1:
return a+b
else:
return function(a,b,counter-1)
I find it tough to get real help in these online courses on edX as well because the courses are so strict on what you can post, and I never got an offer to speak with an individual outside of the "Discussion". I'd pay a premium if I could get 1 on 1 help from edX courses, honestly.
Anyway, hope that helps you.
Related
Please I need help to figure out this. I don't know where I go off.
The Assignment is :
"Write a function investment(PMT, n, i) that calculates your customer's savings at some point in the future, if:
an amount is invested at the END of every year, starting with amount
of PMT at the end of this year,
at an interest rate of i% per year, compounded annually,
the investment amount doubles every second year (cumulatively)."
And there is my code:
def investment(PMT, n, i):
x = 0
while x < n:
if x % 2 == 1:
PMT = 2*(PMT*(1 + i)**n)
else:
PMT = PMT*(1 + i)**n
x = x + 1
investment_balance = PMT
return round(investment_balance, 2)
The answer supposed to be: investment(15000, 30, 0.1045) == 1954935238.47 but I am getting: 3.4728768295747016e+47.
The formula you're using looks like the one you'd use to calculate the future value of money with compound interest. That's on the right track, but you don't want to do that computation in a loop. Your results will be too large.
Try this instead.
Set the initial investment balance to 0.
Start looping over x number of years.
If the year is odd (because we start counting at 0), double the payment.
Apply the interest to the balance.
Add the payment to the balance.
It's important to do that last step last because we're only adding the payment at the end of each year. That means interest shouldn't be applied in year 0. (More accurately, it will be applied to a 0 balance.)
If you do all that, you get a function that looks like this:
def investment(PMT, n, i):
x = 0
investment_balance = 0
while x < n:
if x % 2 == 1:
PMT = 2* PMT
investment_balance *= (1 + i)
investment_balance += PMT
x = x + 1
return round(investment_balance, 2)
This works for the example input you gave.
A couple observations:
Since the payment is made at the end of the year and interest is i% per year there should be no interest at the end of the first year.
If the investment doubles every second year you could calculate the effective interest rate over 2 years and then compound bi-annually (every second year). As in run this as a normal compound interest equation where PMT is doubled each compounding. Should make the logic a little easier. For odd n's you'd have to do a last compounding using the original rate.
Your equation is overwriting PMT on each loop. The PMT doesn't increase with interest, only doubled every second year. If PMT was $100 in year 0, it should only be $200 in year 2 instead of being compounded three times by your loop.
So I am attempting to implement a bisection search algorithm in Python that returns an "optimal" savings rate.
I've tried creating several different functions, and I don't understand why the program gets caught in an infinite loop. I do know that the abs(current_savings - down_payment) is what causes the recursive infinite loop but I do not know why.
First things first, this doesn't really explain why my program doesn't work but here goes:
At the end of each month I earn interest on current savings, which is
applied first, and then I receive my monthly salary, which is just
1/12 of my annual salary.
I am attempting to find the best rate to apply to my monthly salary, to then add to my current savings.
My first function simply checks to see if one's salary is high enough to ever save for the 250K down payment. If their salary is not high enough, it prints that it is not adequate and returns False.
My second function attempts to find the best rate ("portion saved"), or the best rate to save of monthly salary in order to fall within 100 dollars of the down_payment. In addition, I must record the number of "steps" my bisection search function takes to find the optimal rate.
Here is the code:
#Givens
annual_salary = 150000
initial_salary = annual_salary
interest_rate = float(0.04/12.0)
down_payment = float(250000.0)
semi_annual_raise = 0.07
#Bisect-search
low = float(0.0)
high = float(10000.0)
portion_saved = float((low+high)/2)
current_savings = 0
months = 0
steps = 0
def isPossible(annual_salary):
count = 0
current_savings = 0
while count < 36:
current_savings += (current_savings*interest_rate) + (annual_salary/12)
count += 1
if count % 6 == 0:
annual_salary += (annual_salary*semi_annual_raise)
if current_savings < down_payment:
print("It is not possible to pay the down payment in three years.")
return False
else:
return True
def bisearch(initial_salary,interest_rate,down_payment,semi_annual_raise,low,high,portion_saved,steps):
current_savings = 0
months = 0
while abs(current_savings - down_payment) > 100.0:
months = 0
current_savings = 0
while months < 36:
current_savings = current_savings + (initial_salary*interest_rate)
current_savings = current_savings + (initial_salary/12*portion_saved/10000.0)
months += 1
if months % 6 == 0:
initial_salary += (initial_salary*semi_annual_raise)
steps += 1
if current_savings > down_payment:
high = portion_saved
else:
low = portion_saved
portion_saved = ((low+high)/2.0)
print("Best saving rate: ", (portion_saved/10000.0))
print("Steps in bisection search: ", steps)
if isPossible(annual_salary) == True:
bisearch(initial_salary,interest_rate,down_payment,semi_annual_raise,low,high,portion_saved,steps)
And the test cases:
Note: the number of bisection search steps doesn't have to be the same, but the rate should be the same
Test Case 1
Enter the starting salary: 150000
Best savings rate: 0.4411
Steps in bisection search: 12
Test Case 2
Enter the starting salary: 300000
Best savings rate: 0.2206
Steps in bisection search: 9
If anyone could help me out I would greatly appreciate it, been at this for hours trying to come up with a fix.
I was confused in the same problem and finally found a solution. Try resetting initial_salary back to annual_salary inside the first while loop within your bisection function, else that would just keep on increasing every time you hit six months on the inner loop. Does that work?
I'm struggling with a problem that calculates the minimum fixed monthly payment needed in order pay off a credit card balance within 12 months. By a fixed monthly payment, I mean a single number which does not change each month, but instead is a constant amount, multiple of 10 and the same for all months, that will be paid each month. ( it is possible for the balance to become negative using this payment scheme, which is OK)
So as input I have
original_balance = 3329
annualInterestRate = 0.2
From this I'm calculating the followings :
after_12_months_interest = original_balance
monthlyInterestRate = round(annualInterestRate/12.0,2)
monthly_payment = 10
total_paid = 0
for i in range(0,12):
after_12_months_interest = after_12_months_interest + (annualInterestRate/12.0)*after_12_months_interest
while total_paid < after_12_months_interest:
new_balance = 0
unpaid_balance = original_balance - monthly_payment
total_paid = 0
for i in range(0, 13):
total_paid = total_paid + monthly_payment
if total_paid < after_12_months_interest:
monthly_payment = monthly_payment + 10
print "Lowest Payment: ", monthly_payment
My problem I have is that I end up having a monthly_payment just a little more than I should have it. In this case the return for the monthly_payment is 320 instead of 310. For all use cases I've tried the monthly_payment it's slightly more than it should be.
Anyone can give me a hint or an idea on what I'm doing wrong please. Thank you
Mandatory one-liner
from itertools import count
print(next(payment for payment in count(0, 10)
if sum(payment*(1+monthly)**i for i in range(12)) > original_balance*(1+annual)))
What this does:
next takes the first element of an iterator.
count tries values from 0 to infinity (only each time next is called, and only until a value is returned)
sum(payment*(1+monthly)**i for i in range(12)) That's the combined value of the payments. Each payment is worth itself plus all the saved interests (the earlier you repay, the less interest you'll owe later)
original_balance*(1+annual) is indeed the total value if nothing is repayed.
Alternative
print(next(payment for payment in count(0, 10)
if reduce(lambda x,_:(x - payment)*(1+monthly), range(12), original_balance) <= 0))
This one computes the combined remainder of the debt by reduceing the original_balance 12 times.
I am trying to teach myself python and have no experience write code. For my first attempt I am trying to write a program that applies the snowball principle to debt reduction, but also adds in an extra set amount each payment. I can get the first debt to clear(it goes to a negative but it exits the loop). My second step wont exit the loop and I have looked at topics that dealt with nested loops but they did not help. Could someone please show me where I went wrong?
#Temp fixed number for testing use rawinput for actual program.
#name the debt
debt1 = "CC A"
#currnet balnace
balance1 = float(5000)
#APR
annualInterestRate1 = float(.1499)
#Currnet Monthly Payment
minMonthlyPayment1 = float(200)
# Exta Payment
boosterPayment = float(337)
print "The balance on ",debt1," is ",balance1
debt2 = "CC B"
balance2 = float(1000)
annualInterestRate2 = float(.1499)
minMonthlyPayment2 = float(200)
print "The balance on ",debt2," is ",balance2
debt3 = "ICCU"
balance3 = float(6000)
annualInterestRate3 = float(.0879)
minMonthlyPayment3 = float(130)
print "The balance on ",debt3," is ",balance3
debt4 = "Car"
balance4 = float(8000)
annualInterestRate4 = float(.0699)
minMonthlyPayment4 = float(200)
print "The balance on ",debt4," is ",balance4
debt5 = "Truck"
balance5 = float(15000)
annualInterestRate5 = float(.0439)
minMonthlyPayment5 = float(333)
#nubmer of payments made durning the debt reduction. Used as the index.
numPay = 0
save = 0
#For Debt1 with an APR greater then 0
intPayment1 = round(balance1*(annualInterestRate1/12),2)
while balance1 >= 0:
#payment with intrest
payment1 = minMonthlyPayment1 - intPayment1 + boosterPayment
#subtact payment from balance
balance1 -= payment1
#count Number of payments
numPay += 1
print numPay
print balance1
#For Debt2 with an APR greater then 0
#Figures monthly charge based on given APR
intPayment2 = round(balance2*(annualInterestRate2/12),2)
#Monthly payment minus intrest
standPay2 = minMonthlyPayment2 - intPayment2
while balance2 >= 0:
#payment while debt1 is being paid
#need a way to pay the payments while the other debt is being figured
backPay = numPay
while backPay >= 0:
balance2 -= standPay2
backPay += 1
#payment with intrest takes 100 away for savings
payment2 = minMonthlyPayment2 - intPayment2 + (boosterPayment-100)
#subtact payment from balance
balance2 -= payment2
#count Number of payments
numPay += 1
#keep track of how much is going to savings
save += 100
print numPay
print balance1
print save
Take a look at this loop:
while backPay >= 0:
balance2 -= standPay2
backPay += 1
Here, backPay in increased in each iteration, so the condition backPay >= 0 will always be true.
Not sure what the code is intended to do, but probably you have to do backPay -= 1 instead. However, note that since the number of iterations of the loop is known beforehand, and you are just adding a fixed number in each iteration, you could just as well replace the loop with a simple multiplication.
How to calculate the monthly fee on a loan?
Given is:
a: an amount to loan.
b: the loan period (number of months).
c: the interest rate p.a. (interests is calculated and added every month, 1/12 of the interest is added. So if the interest is on 12%, 1% interest is added every month).
d: the amount of money owed after the end of the period.
This problem is a bit different than the usual since, the goal is not to have the loan payed after the loan period has ended, but to still owe an amount that is given. I have been able to find an algorithm so solve the problem if I wanted to pay the entire amount, but it will of course not work for this problem where the goal is to end up owing a given amount rather than not owing anything.
I managed to make a solution to this problem by starting with an guess and then keep on improving that guess until it was close enough. I wondered however, if there is a better way to simply calculate this, rather than just guessing.
Edit: Here's how I'm doing it now.
def find_payment(start, end, months, interest):
difference = start
guess = int(start / months * interest)
while True:
total = start
for month in range(1, months + 1):
ascribe = total * interest / 12
total = total + ascribe - guess
difference = total - end
# See if the guess was good enough.
if abs(difference) > start * 0.001:
if difference < 0:
if abs(difference) < guess:
print "payment is %s" % guess
return evolution(start, guess, interest, months)
else:
mod = int(abs(difference) / start * guess)
if mod == 0:
mod = 1
guess -= mod
else:
mod = int(difference / start * guess)
if mod == 0:
mod = 1
guess += mod
else:
print "payment is %s" % guess
return evolution(start, guess, interest, months)
evolution is just a function that displays how the loan would look like payment for payment and interest for interest, summing up total amount of interest paid etc.
An example would be if I wanted to find out the monthly payments for a loan starting with $100k and ending at $50k with an interest of 8% and a duration of 70 months, calling
>>> find_payment(100000, 50000, 70, 0.08)
payment is 1363
In the above case I would end up owing 49935, and I went through the loop 5 times. The amount of times needed to go through the loop depends on how close I want to get to the amount and it varies a bit.
This is a basically a mortgage repayment calculation.
Assuming that start is greater than end, and that interest is between 0 and 1 (i.e. 0.1 for 10% interest)
First consider the part of the payment you want to pay off.
Principal = start - end
The monthly payment is given by:
pay_a = (interest / 12) / (1 - (1+interest/12) ^ (-months))) * Principal
You then need to consider the extra interest. Which is just equal to the remaining principal times the monthly interest
pay_b = interest / 12 * end
So the total payment is
payment = (interest / 12) * (1 / (1 - (1+interest/12) ^ (-months))) * Principal + end)
On the example you gave of
Start: 100000
End: 50000
Months: 70
Interest: 8%
pay_a = 896.20
pay_b = 333.33
Payment = 1229.54
When I tested these values in Excel, after 70 payments the remaing loan was 50,000. This is assuming you pay the interest on the notional before the payment is made each month.
Perhaps the easiest way to think about this is to split the loan in two parts, one part which is to be repaid in full and another part where you don't pay off anything. You have already computed the monthly fee for the first part.
You can keep paying the interest of every month; then, you will alway owe the same amont.
Owe_1 = a
Int_2 = Owe_1*(InterestRate/12)
Pay_2 = Int_2
Owe_2 = Owe_1 + Int_2 - Pay_2 # ==> Owe_1 + Int_2 - Int_2 = Owe_1
Int_3 = Owe_2*(InterestRate/12)
Pay_3 = Int_3
Owe_3 = Owe_2 + Int_3 - Pay_3 # ==> Owe_2 + Int_3 - Int_3 = Owe_2 = Owe_1
python code to calculate emi
class EMI_CALCULATOR(object):
# Data attributes
# Helps to calculate EMI
Loan_amount = None # assigning none values
Month_Payment = None # assigning none values
Interest_rate = None #assigning none values
Payment_period = None #assigning none values
def get_loan_amount(self):
#get the value of loan amount
self.Loan_amount = input("Enter The Loan amount(in rupees) :")
pass
def get_interest_rate(self):
# get the value of interest rate
self.Interest_rate = input("Enter The Interest rate(in percentage(%)) : ")
pass
def get_payment_period(self):
# get the payment period"
self.Payment_period = input("Enter The Payment period (in month): ")
pass
def calc_interest_rate(self):
# To calculate the interest rate"
self.get_interest_rate()
if self.Interest_rate > 1:
self.Interest_rate = (self.Interest_rate /100.0)
else:
print "You have not entered The interest rate correctly ,please try again "
pass
def calc_emi(self):
# To calculate the EMI"
try:
self.get_loan_amount() #input loan amount
self.get_payment_period() #input payment period
self.calc_interest_rate() #input interest rate and calculate the interest rate
except NameError:
print "You have not entered Loan amount (OR) payment period (OR) interest rate correctly,Please enter and try again. "
try:
self.Month_Payment = (self.Loan_amount*pow((self.Interest_rate/12)+1,
(self.Payment_period))*self.Interest_rate/12)/(pow(self.Interest_rate/12+1,
(self.Payment_period)) - 1)
except ZeroDivisionError:
print "ERROR!! ZERO DIVISION ERROR , Please enter The Interest rate correctly and Try again."
else:
print "Monthly Payment is : %r"%self.Month_Payment
pass
if __name__ == '__main__':# main method
Init = EMI_CALCULATOR() # creating instances
Init.calc_emi() #to calculate EMI
for more info visit : https://emilgeorgejames.wordpress.com/2015/07/29/python-emi-equated-monthly-installment-calculator/
This rather a detailed way but will give the whole payment as well
# Mortgage Loan that gives the balance and total payment per year
# Function that gives the monthly payment
def f1 (principle,annual_interest_rate,duration):
r = annual_interest_rate/1200
n = duration*12
a=principle*r*((1+r)**n)
b= (((1+r)**n)- 1)
if r > 0 :
MonthlyPayment = (a/b)
else :
MonthlyPayment = principle/n
return MonthlyPayment
# Function that gives the balance
def f2 (principle,annual_interest_rate,duration,number_of_payments):
r = annual_interest_rate/1200
n = duration*12
a= ((1+r)**n)
b= ((1+r)**number_of_payments)
c= (((1+r)**n)-1)
if r > 0 :
RemainingLoanBalance = principle*((a-b)/c)
else :
RemainingLoanBalance = principle*(1-(number_of_payments/n))
return RemainingLoanBalance
# Entering the required values
principle=float(input("Enter loan amount: "))
annual_interest_rate=float(input("Enter annual interest rate (percent): "))
duration=int(input("Enter loan duration in years: "))
# Output that returns all useful data needed
print ("LOAN AMOUNT:",principle,"INTEREST RATE (PERCENT):",annual_interest_rate)
print ("DURATION (YEARS):",duration,"MONTHLY PAYMENT:",int(f1(principle,annual_interest_rate,duration)))
k=duration+1
BALANCE=principle
total=0
for i in range (1,k):
TOTALPAYMENT= f1(BALANCE,annual_interest_rate,k-i)*12
total+= TOTALPAYMENT
BALANCE= f2(principle,annual_interest_rate,duration,12*i)
print("YEAR:",i,"BALANCE:",int(BALANCE),"TOTAL PAYMENT",int(total))
How about this?
def EMI_calc(principle, rate, time, frequency):
return (principle / ((1-((1+(rate/frequency))**(-1*(time*frequency))))/(rate/frequency)))
print("""
----- Welcome to EMI programe for Python -----
""")
print("\n You have chosen to know the EMI for Loan.\n")
input('\nTo Continue Press ENTER --- to ABORT Press ctrl+c > \n')
print("\nPlease Enter amount of Loan to be taken: >\n")
principle = int(input())
print("\nEnter rate of interst (%): >\n")
rate = float(input())/100
print("\nEnter Term (Years): >\n")
time = float(input())
print("\nPlease enter the frequency of installments) : >\n")
frequency = int(input())
EMI = round(EMI_calc(principle, rate, time, frequency),0)
print("""
---------------------------------------------------------------------
""")
print(f"""
The EMI for Loan of Rs.{principle};
at interest rate of {rate*100} % for {time} years;
would be: Rs.""", EMI)
print("""
---------------------------------------------------------------------
""")
Here is a code snippet using numpy functions. This shows you the payment, principal, interest, instalment and total_amount each month. Run it and see the output. You can also check the syntax for Excel "IPMT()" and "PPMT()" functions for more explanation of the arguments.
https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.pmt.html#numpy.pmt
import math
import numpy as np
rate = 0.08
start_amount = 100000.0
end_amount = 50000.0
diff_amount = start_amount - end_amount
# nr_years = 4
payment_frequency = int (12)
nr_months = 70 # = nr_years * payment_frequency
per_np = np.arange (nr_months) + 1 # +1 because index starts with 1 here
pay_b = rate / payment_frequency * end_amount
ipmt_np = np.ipmt (rate / payment_frequency, per_np, nr_months, diff_amount) - pay_b
ppmt_np = np.ppmt (rate / payment_frequency, per_np, nr_months, diff_amount)
for payment in per_np:
idx = payment - 1
principal = math.fabs (ppmt_np [idx])
start_amount = start_amount - principal
interest = math.fabs (ipmt_np [idx])
instalment = principal + interest
print payment, "\t", principal, "\t", interest, "\t\t", instalment, "\t\t", start_amount
print np.sum (ipmt_np)