def inflation(price_today: int, price_last_year: int) -> float:
  inflation_rate = ((price_today - price_last_year) / price_last_year) * 100 
  return inflation_rate

def semiperimeter_calculation(side_a: float, side_b: float, side_c: float) -> float:
    sp = (side_a + side_b + side_c)/2
    return sp

def area_calculation(sp: float, side_a: float, side_b: float, side_c: float) -> float:
    area = (sp*((sp - side_a)*(sp - side_b)*(sp - side_c))) ** 0.5
    return area

side_a = float(input("Enter the length of side a: "))
side_b = float(input("Enter the length of side b: "))
side_c = float(input("Enter the length of side c: "))
sp = semiperimeter_calculation(side_a, side_b, side_c)
area = area_calculation(sp, side_a, side_b, side_c)

print(f'''The area of a triangle with side lengths of 
	{side_a:.2f}, {side_b:.2f}, {side_c:.2f} is {area:.2f}.''')

import math

# Rounding a number up to the nearest whole number.
# Using the math.ceil() method, as found from:
# "Python Round to Int - How to Round Up or Round Down to Nearest Whole Number"
# https://www.freecodecamp.org/news/how-to-round-numbers-up-or-down-in-python/.
def cake_time(temp: int, d: float) -> int:
    cake_time = math.ceil(20 + 350 * (area(d) - area(6)) / (2 * temp))
    print(f'Your cake should take about {cake_time} minutes to bake.')
    return cake_time

def area(diameter: float) -> float:
    cake_pan_area = math.pi * (1/4) * diameter ** 2
    return cake_pan_area

def main() -> None:
    oven_temp = int(input("Enter the temperature in °F (between 300 and 450): "))
    cake_pan_diameter = float(input("Enter the cake pan diameter "))
    cake_pan_area = area(cake_pan_diameter)

    cake_time(oven_temp, cake_pan_diameter)

main()

triangle_num = int((num_items * (num_items + 1) / 2))

def redact(redacted_name:str,d:str, '#' )->None:
    redacted_name= name.replace('dog','#')
    print(redacted_name)

print(f"Final values for stock purchased at ${str(stock_round_down)} {stock_remainder}/4 and held for {str(time_held)} years \nat {str(growth_input)}% growth rate: ${str(fv_round_down)} {str(fv_remainder)}/4 (${str(npv_optimistic_round_down)} {str(npv_optimistic_remainder)}/4 in today's dollars.)")

def net_present_value(conservative_FV: float, number_of_years:float) -> float:
    FV = conservative_FV
    i = 0.033
    t = number_of_years
    conservative_NPV = FV *(1+i)**-t
    return conservative_NPV

PTS_PER_GOLD = 3
PTS_PER_SILVER = 2
PTS_PER_BRONZE = 1

def gold_pts(g):
  g = g + 1
  return g * PTS_PER_GOLD

def silver_pts(s):
  s = s - 1
  return s * PTS_PER_SILVER

def bronze_pts(b):
  b = b # No, this doesn't make sense.
  return b * PTS_PER_BRONZE

def total_pts(g,s,b):
  return gold_pts(g) + silver_pts(s) + bronze_pts(b)

def main():
  gold = 1
  silver = 2
  bronze = 3
  PTS_PER_BRONZE = 1000
  tp = total_pts(gold, silver, bronze)
  print(tp, bronze, silver, gold)

gold = 3
silver = 1
bronze = 2

main()

print(gold, silver, bronze)

# use debugger to see what's going on

from math import ceil, factorial, isclose

a = ceil(2.4)
b = factorial(4)
c = isclose(0.1 + 0.2, 0.3)

print(a, b, c)

from random import randint, choice, uniform

a = randint(3, 10)
b = choice(['Bob', 'Mariko', 'Said', 'Hatoon'])
c = uniform(0.0, 100.0)

print(a, b, c)

import pytest
from redactor import redact

import pytest
from triangular_scoring import score

import hello
out, _ = capsys.readouterr()
assert out == "Hello, world!\n"

def foo() -> None:
  "Wait, so THIS is a docstring?!?"
  print("foo de foo")

def cake_time(oven_temp: int, pan_diameter: float) -> int:
  """Return the number of minutes (rounded up) to bake a cake."""
  
  time = 20 + (350 * (area(pan_diameter) - area(6))) / (2 * oven_temp)
  return math.ceil(time)

def cake_time(oven_temp: int, pan_diameter: float) -> int:
  """Return the number of minutes (rounded up) to bake a cake."""

def landing_point(angle: float, velocity: float) -> float:
    """Computes the horizontal distance a projectile will travel.

    Uses projectile kinematics to determine the horizontal distance
    travelled by a projectile when launched at some `angle` with
    some `velocity`.

    This, by the way, is an example of a formal NumPy/SciPy docstring.
    It is supposed to be written in a very specific format 
    (see https://numpydoc.readthedocs.io/en/latest/format.html), and
    then turned into formal documentation by software tools.

    Parameters
    ----------
    angle : float 
        Launch angle of projectile from horizontal, in degrees.
    velocity : float
        Launch velocity of projectile, in meters / second.

    Returns
    -------
    float 
        Distance travelled by projectile along horizontal, in meters.
    """