Python problems on loops 3 solution

1. Accumulating Savings

Description: Calculate how many months it will take to save up to a target amount with a fixed monthly saving and an annual interest rate.

Input: Monthly saving (e.g., 500), Target amount (e.g., 10000), Annual interest rate (e.g., 0.05)

Output: Number of months (e.g., 20 months)

Complete Code:

monthly_saving = 500
target_amount = 10000
annual_interest_rate = 0.05
total_savings = 0
months = 0
while total_savings < target_amount:
    total_savings += monthly_saving
    total_savings += total_savings * (annual_interest_rate / 12)  # Monthly interest
    months += 1
print("Number of months to reach target:", months)

Explanation: The code adds the monthly saving to the total savings and then adds the interest earned on the total savings each month until the target amount is reached.

2. Debt Repayment Plan

Description: Calculate how long it will take to repay a loan with fixed monthly payments and an annual interest rate.

Input: Loan amount (e.g., 5000), Monthly payment (e.g., 200), Annual interest rate (e.g., 0.07)

Output: Number of months to repay (e.g., 28 months)

Complete Code:

loan_amount = 5000
monthly_payment = 200
annual_interest_rate = 0.07
months = 0
while loan_amount > 0:
    interest = loan_amount * (annual_interest_rate / 12)  # Monthly interest
    loan_amount += interest - monthly_payment
    months += 1
print("Number of months to repay the loan:", months)

Explanation: The code calculates the interest on the remaining loan amount each month, subtracts the monthly payment, and keeps track of the number of months until the loan is repaid.

3. Investment Doubling Time

Description: Calculate how long it takes for an investment to double given a fixed annual interest rate.

Input: Initial investment (e.g., 1000), Annual interest rate (e.g., 0.08)

Output: Number of years (e.g., 10 years)

Complete Code:

initial_investment = 1000
annual_interest_rate = 0.08
current_amount = initial_investment
years = 0
while current_amount < 2 * initial_investment:
    current_amount += current_amount * annual_interest_rate  # Annual interest
    years += 1
print("Number of years to double the investment:", years)

Explanation: The code adds the interest earned each year to the current amount until it doubles the initial investment, counting the number of years it takes.

4. Break-Even Point for Investment

Description: Calculate the number of years until the investment surpasses a break-even point considering the annual investment cost and return rate.

Input: Initial investment (e.g., 5000), Annual cost (e.g., 500), Annual return rate (e.g., 0.1)

Output: Number of years to break even (e.g., 26 years)

Complete Code:

initial_investment = 5000
annual_cost = 500
annual_return_rate = 0.1
years = 0
while initial_investment > 0:
    initial_investment = (initial_investment - annual_cost) * (1 + annual_return_rate)
    years += 1
print("Number of years to break even:", years)

Explanation: The code deducts the annual cost from the investment and then applies the return rate, repeating this process until the investment surpasses the break-even point.

5. Reaching a Financial Goal

Description: Calculate how long it will take for your savings to reach a financial goal with a starting amount, monthly contribution, and an annual interest rate.

Input: Starting amount (e.g., 2000), Monthly contribution (e.g., 150), Financial goal (e.g., 10000), Annual interest rate (e.g., 0.04)

Output: Number of months (e.g., 48 months)

Complete Code:

starting_amount = 2000
monthly_contribution = 150
financial_goal = 10000
annual_interest_rate = 0.04
total_amount = starting_amount
months = 0
while total_amount < financial_goal:
    total_amount += monthly_contribution
    total_amount *= (1 + (annual_interest_rate / 12))  # Monthly interest
    months += 1
print("Number of months to reach the financial goal:", months)

Explanation: The code adds the monthly contribution to the total amount and then applies the monthly interest until the financial goal is reached.

6. Dividend Reinvestment Plan (DRIP)

Description: Calculate the total shares owned after a certain number of years when dividends are reinvested to purchase additional shares.

Input: Initial shares (e.g., 100), Annual dividend per share (e.g., 2), Share price (e.g., 50), Number of years (e.g., 5)

Output: Total shares owned (e.g., 121.6)

Complete Code:

shares = 100
dividend_per_share = 2
share_price = 50
years = 5
while years > 0:
    dividends = shares * dividend_per_share
    shares += dividends / share_price  # Reinvest dividends to purchase more shares
    years -= 1
print("Total shares owned after DRIP:", round(shares, 2))

Explanation: The code calculates the dividends earned each year and reinvests them to purchase additional shares, repeating this process for the specified number of years.

7. Inflation Impact on Savings

Description: Calculate the real value of your savings after a number of years, considering a constant annual inflation rate.

Input: Initial savings (e.g., 10000), Number of years (e.g., 5), Annual inflation rate (e.g., 0.03 for 3%)

Output: Real value of savings after specified years (e.g., 8587.34)

Complete Code:

initial_savings = 10000
years = 5
inflation_rate = 0.03
for _ in range(years):
    initial_savings -= initial_savings * inflation_rate  # Apply annual inflation rate
print("Real value of savings after", years, "years:", round(initial_savings, 2))

Explanation: The code reduces the initial savings by the inflation rate each year, calculating the real value of the savings after the specified number of years.

8. Real Estate Investment Return

Description: Calculate the total return on a real estate investment, considering monthly rental income, property appreciation, and the duration of the investment.

Input: Monthly rental income (e.g., 1200), Annual appreciation rate (e.g., 0.03), Initial property value (e.g., 300000), Investment duration in years (e.g., 5)

Output: Total return (e.g., 119782.22)

Complete Code:

rental_income = 1200
appreciation_rate = 0.03
property_value = 300000
duration_years = 5
total_return = 0
months = duration_years * 12
initial_property_value = property_value
while months > 0:
    total_return += rental_income
    if months % 12 == 0:
        property_value += property_value * appreciation_rate  # Annual property appreciation
    months -= 1
total_return += property_value - initial_property_value  # Add the property appreciation
print("Total return on real estate investment:", total_return)

Explanation: The code adds the monthly rental income and annual property appreciation to the total return, repeating this process for the specified duration.

9. Dollar-Cost Averaging Investment

Description: Calculate the total value of an investment using a dollar-cost averaging strategy, given monthly contributions, and variable monthly growth rates.

Input: Monthly contribution (e.g., 500), List of monthly growth rates (e.g., [0.01, -0.01, 0.02])

Output: Total investment value (e.g., 1524.85)

Complete Code:

monthly_contribution = 500
growth_rates = [0.01, -0.01, 0.02]
total_value = 0
for growth_rate in growth_rates:
    total_value += monthly_contribution
    total_value += total_value * growth_rate  # Apply monthly growth rate
print("Total value of dollar-cost averaging investment:", round(total_value, 2))

Explanation: The code adds the monthly contribution to the total value and then applies the monthly growth rate, repeating this process for each month in the list of growth rates.

10. Pension Fund Future Value

Description: Calculate the future value of a pension fund, given an initial balance, monthly contributions, an annual interest rate, and a duration in years.

Input: Initial balance (e.g., 50000), Monthly contribution (e.g., 200), Annual interest rate (e.g., 0.06), Duration in years (e.g., 20)

Output: Future value of the pension fund (e.g., 258380.44)

Complete Code:

initial_balance = 50000
monthly_contribution = 200
annual_interest_rate = 0.06
duration_years = 20
total_balance = initial_balance
months = duration_years * 12
while months > 0:
    total_balance += monthly_contribution
    total_balance += total_balance * (annual_interest_rate / 12)  # Monthly interest
    months -= 1
print("Future value of the pension fund:", round(total_balance, 2))

Explanation: The code adds the monthly contribution to the total balance and then applies the monthly interest, repeating this process for the specified duration in years.