Principles of Financial Computing Course

Principles of Financial Computing

Time: 14:20 ~ 17:20 Thursday (Fall Semester)
Location: Room 110 of the CSIE Building


On Wall Street, being right on the fundamentals and
wrong on the timing is the same as just being wrong.
---Jonathan Cohen

Where is the risk management at J.P. Morgan Chase?
--- Bloomberg News, January 16, 2002

10. Of course, I make a lot investing.
I only teach so I can help young people.
--- Top Ten Lies Finance Professors Tell Their Students



To Students,

You will learn a perhaps different perspective on finance, especially as it pertains to pricing and software engineering. Our emphasis on computation should add a new dimension and toolbox to your existing knowledge and financial sense. (But see Enrollments below.)
It is your responsibility to learn to write in high-level programming languages. We cannot impart that skill in the class. If the mathematics proves hard going, you are expected to fill in the gap by self-reading. The technicalities are not beyond a motivated graduate student's reach.


The major topics covered in the course, time permitting, are listed below for your reference.


Notes [ 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025 (spring), 2025 (fall), 2026 ]

  1. 2026.09.10
  2. 2026.09.17
  3. 2026.09.24
  4. 2026.10.01
  5. 2026.10.08 & 1st assignment due
  6. 2026.10.15
  7. 2026.10.22
  8. 2026.10.29
  9. 2026.11.05 & 2nd assignment due
  10. 2026.11.12
  11. 2026.11.19
  12. 2026.11.26 & 3rd assignment due
  13. 2026.12.03
  14. 2026.12.10
  15. 2026.12.17
  16. 2026.12.24 & 4th assignment due & test

Programming Exercises

Homework should be turned in on time. No late homework will be accepted without legitimate reasons. There will be four to six programming assignments.
Treat each homework as an examination.
  1. Consider a commercial property loan of amount V with a total duration of n3 years and m compounding payments per year at annual interest rate r1. In the first n1 years, payments only cover interest (the interest-only grace period, with no principal amortization). In the next n3 − n1 years, equal periodic amortizing payments repay the loan.

    After a duration of n2 years from loan inception (where n1 < n2 < n3), immediately after making the year-end payment, the borrower has an option to refinance the remaining loan balance B into a new loan at annual interest rate r2 for the remaining n3 − n2 years again with m payments per year. Refinancing incurs a fixed upfront fee F and a prepayment penalty fraction α on the remaining balance B, both paid out-of-pocket in cash by the borrower at year n2.

    Write a program to calculate:

    1. Regular periodic payment amount after the grace period;
    2. Remaining loan balance B;
    3. Total interest saved by refinancing over the n3 − n2 years;
    4. Annualized net internal rate of return (IRR) of the refinancing decision.

    The annualized net IRR is defined as m × y, where the periodic IRR y is the unique rate satisfying:

    C0 = ∑t=1K (ΔPMT) / (1 + y)t = (ΔPMT) × [1 − (1 + y)−K] / y

    where:
    • C0 = F + α × B is the upfront cash outflow (refinancing fee plus the prepayment penalty on B);
    • K = (n3 − n2) × m is the total number of payments;
    • ΔPMT = PMTold − PMTnew is the periodic cash savings from refinancing.

    Inputs:

    • V: original loan amount in dollars, a float or integer;
    • m: number of payments per annum, a positive integer;
    • n1: duration of the initial interest-only grace period in years, a positive integer;
    • n2: duration from loan inception to refinancing in years (n1 < n2 < n3), an integer;
    • n3: duration of the original loan in years, a positive integer;
    • r1: annual interest rate of the original loan (compounded m times per annum), a float;
    • r2: annual interest rate of the refinanced loan (compounded m times per annum), a float;
    • F: upfront closing fee for the new loan in dollars, a float;
    • α: prepayment penalty rate on the remaining loan balance (a fraction between 0 and 1, e.g., 0.01 for 1%), a float.

    Outputs:

    • regular payment amount after grace period;
    • remaining balance after duration n2;
    • total interest saved over the remaining term;
    • annualized net IRR.

    Example:
    If V = 10000000, m = 12, n1 = 3, n2 = 5, n3 = 20, r1 = 0.025, r2 = 0.018, F = 50000, and α = 0.01:

    • Input Format (for Python, replace with your student ID in uppercase):
      python3 D13922016_HW_1.py 10000000 12 3 5 20 0.025 0.018 50000 0.01
    • Output Format (comma-separated):
      60222.193744, 9031668.918858, 527518.711395, 0.243936

    Please submit your source (and executable) code and a brief explanation text file (if the code is not written in Python, describe how to compile and run it) via Gradescope in NTU COOL before 08:00 AM (GMT+8) 2026 Oct 8. No late submissions will be accepted. Compress all files into a single zip file named ID_HW_i.zip, where ID is your student ID in uppercase and i is the homework number (e.g., D13922016_HW_1.zip). If the code is not written in Python, you may be asked to demonstrate your code to the TA.

  2. Write a program to price a structured note and calculate its key financial metrics. Consider an investor who deposits a domestic principal amount D into a structured note that pays an enhanced coupon rate c (annualized) at maturity T. Let St denote the FX spot rate at time t, expressed as domestic currency per unit of foreign currency. At maturity T, the investor receives the guaranteed coupon payment D × c × T in the domestic currency. If the terminal FX spot rate ST ≥ X, the investor receives their full principal D back in domestic currency. If ST < X, the principal D is converted into foreign currency at the conversion strike rate X (yielding D / X units of foreign currency, worth (D / X) · ST in domestic terms). Your goal is to compute the fair value of the note at t = 0 (in domestic currency), the delta of the note with respect to the initial FX spot rate S0, the breakeven spot rate at maturity (ST* such that total terminal payout equals initial principal D).

    Inputs:

    • D: domestic principal amount, a float;
    • T: time to maturity in years, a float;
    • c: enhanced annual coupon rate, a float;
    • S0: initial FX spot rate at t = 0, domestic per unit of foreign, a float;
    • X: conversion strike exchange rate, a float;
    • rd: domestic risk-free interest rate, a float;
    • rf: foreign risk-free interest rate, a float;
    • σ: FX spot volatility, a float.

    Outputs:

    • Fair value of the note in domestic currency;
    • Delta with respect to S0;
    • Breakeven spot rate ST* at maturity.

    For Example, if D = 1000000, T = 1.0, c = 0.06, S0 = 32.0, X = 31.5, rd = 0.015, rf = 0.005, σ = 0.12, the outputs are 1006065.998257, 13119.408633, 29.716981. Input Format (for Python codes, replace the student ID with uppercase): "python3 D13922016_HW_2.py 1000000 1.0 0.06 32.0 31.5 0.015 0.005 0.12". Output Format: "1006065.998257, 13119.408633, 29.716981". Please submit your source (and executable) code and a brief explanation text file (if the code is not written in Python, describe how to compile and run it) via Gradescope in NTU COOL before 08:00 AM (GMT+8) 2026 Nov 5. No late submissions will be accepted. Compress all files into a single zip file named ID_HW_i.zip, where ID is your student ID in uppercase and i is the homework number (e.g., D13922016_HW_2.zip). If the code is not written in Python, you may be asked to demonstrate your code to the TA.

  3. TBA
  4. Write a program that calculates the profit of a carry trade, assuming the domestic currency is the Japanese yen (JPY) and the foreign currency is the U.S. dollar (USD). Consider an m-year loan of J JPY at an interest rate r_j with principal and interest paid at maturity. In the carry trade, use the J JPY to buy USD at the spot exchange rate of S USD/JPY (i.e., 1 USD = S JPY, or equivalently, 1 JPY = 1/S USD, contrary to the convention of the lecture notes), and invest all USD in m-year U.S. treasury notes at an interest rate r_u with principal and interest paid at maturity. To hedge against exchange rate risk, one may buy an m-year USD/JPY put option with strike price X and premium P (JPY per USD) to cover the entire USD position (both principal and interest in USD) at maturity. The premium P is determined by the Black-Scholes formula with an annualized volatility of σ. Suppose the true USD/JPY exchange rate at maturity is F. At maturity, exchange all USD back to JPY and repay the original JPY loan. Inputs:
    • J: the principal amount of the JPY loan;
    • S: the spot USD/JPY exchange rate;
    • m: duration in years;
    • r_j: annual interest rate of the JPY loan;
    • r_u: annual interest rate of the U.S. treasury notes;
    • X: the strike price of the put in USD/JPY;
    • σ: the volatility the Black-Scholes formula;
    • F: the true USD/JPY exchange rate at maturity.
    Outputs:
    • The profit or loss in JPY without the USD/JPY put;
    • The profit or loss in JPY with the USD/JPY put;
    For example, if J = 10000000, S = 170, m = 1, r_j = 0.0025, r_u = 0.0425, X = 160, σ = 0.01, F = 170, the outputs are 409129.287679, 408388.819273. For another example, if J = 10000000, S = 170, m = 20, r_j = 0.0025, r_u = 0.0425, X = 170, σ = 0.01, F = 70, the outputs are -878870.985241, 0. Input Format (for Python codes, replace the student ID with uppercase): "python3 F08922011_HW_2.py 10000000 170 20 0.0025 0.0425 170 0.01 70". Output Format: "-878870.985241, 0". Note that the acceptable relative error tolerance is ±1% (values within this range regarded as correct). Please send your source (and executable) code and a brief explanation txt file (only if the code is not written in Python, describe how to run it) using NTU COOL before 08:00 AM (GMT+8) 2025 Oct 30. No late submissions will be accepted. Compress all files into a single zip file, and name it ID_HW_i.zip, where ID is your student ID in uppercase and i is the number of the homework (example: F08922011_HW_2.zip). If the code is not written in Python, you may be asked to demonstrate your code to the TA, and you still have to submit the files before the deadline.
  5. Write a trinomial tree program to price a down-and-out barrier call. Note that the trinomial tree must match the barrier. Inputs:
    • S: stock price;
    • X: strike price;
    • r: continuously compounded annual interest rate;
    • s: annual volatility;
    • T: time to maturity in days, which is an integer, and there are 365 days in a year;
    • H: down-and-out barrier;
    • n: number of time steps in T, which is an integer.
    Output: The price of the down-and-out barrier put option. For example, if S = 100, X = 90, r = 0.03, s = 0.3, T = 90, H = 80, and n = 500, the example output is 12.433294. Input Format (for Python codes, replace your student ID with uppercase): "python3 F08922011_HW_3.py 100 90 0.03 0.3 90 80 500". Output Format: "12.433294". Note that the acceptable relative error tolerance is ±1% (values within this range regarded as correct). Please send your source (and executable) code and a brief explanation txt file (only if the code is not written in Python, describe how to run it) using NTU COOL before 08:00 AM (GMT+8) 2025 Nov 20. No late submissions will be accepted. Compress all files into a single zip file, and name it ID_HW_i.zip, where ID is your student ID in uppercase and i is the number of the homework (example: F08922011_HW_3.zip). If the code is not written in Python, you may be asked to demonstrate your code to the TA, and you still have to submit the files before the deadline.
  6. Write a least-squares Monte Carlo program to price an American-style Asian call, and use 1, x, x2, x3 as the basis functions. Note that the call's payoff, when exercised early, uses the running average. Output its price and delta. Inputs:
    • S: stock price, which is a float;
    • X: strike price, which is a float;
    • T: time to maturity in days, which is an integer, and there are 365 days in a year;
    • r: continuously compounded annual interest rate, which is a float;
    • s: annual volatility, which is a float;
    • n: number of time steps in T, which is an integer;
    • N: number of simulation paths, which is an integer.
    Output: (1) Price of the call; (2) Delta of the call (caluclated by S × 1.01 and S × 0.99). For example, if S = 100, X = 100, T = 365, r = 0.05, s = 0.3, n = 100, and N = 10000, the example outputs are 8.267197 and 0.604959. Input Format (for Python codes, replace your student ID with uppercase): "python3 F08922011_HW_4.py 100 100 365 0.05 0.3 100 10000". Output Format: "8.267197, 0.604959". Note that the acceptable relative error tolerance is ±10% for the price and ±20% for the delta (values within this range regarded as correct). Please send your source (and executable) code and a brief explanation txt file (only if the code is not written in Python, describe how to run it) using NTU COOL before 08:00 AM (GMT+8) 2025 Dec 18. No late submissions will be accepted. Compress all files into a single zip file, and name it ID_HW_i.zip, where ID is your student ID in uppercase and i is the number of the homework (example: F08922011_HW_4.zip). If the code is not written in Python, you may be asked to demonstrate your code to the TA, and you still have to submit the files before the deadline.
  7. TBA
  8. TBA
  9. Write a program to analyze bond investment financing through a loan. Consider an n-year, V1-dollar loan charging an annual interest rate of r1 (the repayment schedule is by amortization), and an n-year level-coupon bond with a par value of V2 and paying an annual interest rate of r2, where r1 < r2. TA holds C dollars in cash, and intends to take out the loan to purchase the bond. The total sum of cash and loan proceeds will be fully invested in the bond (V1 + C = V2). In addition, TA aims to ensure that the payments for the loan (principal and interest) do not exceed the bond (interest) throughout the investment period. Note that V1 and V2 are integers, and payments and interests should be rounded to six decimal places. Inputs:
    • C: cash in TA's hand;
    • n: time to maturity of the loan and bond in years, an integer;
    • m: the number of payments per annum, an integer;
    • r1: annual interest rate of the loan, compounded m times per year;
    • r2: annual interest rate of the bond, compounded m times per year.
    Outputs:
    • The maximum loan amount (V1, an integer) that TA can apply for balanced payments (the following outputs are with V1 of the maximum loan amount);
    • Total interest paid on the loan (rounded to six decimal places);
    • Total interest received from the bond (rounded to six decimal places);
    • Annualized internal rate of return of the investment (rounded to six decimal places).
    For example, if C = 10000, n = 2, m = 12, r1 = 0.018, r2 = 0.045, the outputs are 968, 18.254282, 987.120000, and 0.046329. Input Format (for Python codes, replace the student ID with uppercase): "python3 F08922011_HW_1.py 10000 2 12 0.018 0.045". Output Format: "968, 18.254282, 987.120000, 0.046329". Please send your source (and executable) code and a brief explanation txt file (if the code is not written in Python, describe how to run it) using NTU COOL before 08:00 AM (GMT+8) 2025 March 21. No late submissions will be accepted. Compress all files into a single zip file, and name it ID_HW_i.zip, where ID is your student ID in uppercase and i is the number of the homework (example: F08922011_HW_1.zip). If the code is not written in Python, you may be asked to demonstrate your code to TA and you still have to submit the files before the deadline.
  10. Write a binomial tree program to price Bermudan options, where early exercise is only allowed on specific dates. Inputs:
    • S: stock price;
    • X: strike price;
    • r: continuously compounded annual interest rate;
    • s: annual volatility;
    • T: time to maturity in days, which is an integer and also an exercise date;
    • m: number of periods per day for the tree, an integer;
    • E: early exercise dates from now, a list of integers.
    Output: The prices of the Bermudan put option and the Bermudan call option. For example, if S = 100, X = 110, r = 0.03, s = 0.3, T = 60, m = 5, and E = 10, 20, 30, 40, 50, the example outputs are 11.248139 and 1.687963. Input Format (for Python codes, replace your student ID with uppercase): "python3 F08922011_HW_2.py 100 110 0.03 0.3 60 5 10 20 30 40 50". Output Format: "11.248139, 1.687963". Please send your source (and executable) code and a brief explanation txt file (if the code is not written in Python, describe how to run it) using NTU COOL before 08:00 AM (GMT+8) 2025 April 18. No late submissions will be accepted. Compress all files into a single zip file, and name it ID_HW_i.zip, where ID is your student ID in uppercase and i is the number of the homework (example: F08922011_HW_2.zip). If the code is not written in Python, you may be asked to demonstrate your code to TA 許家豪 and you still have to submit the files before the deadline.
  11. Write a binomial tree program to price up-and-out and up-and-in barrier options. Note that the binomial tree may not align exactly with the barrier. Adjust the barrier by rounding it up to the nearest tree level. Inputs:
    • S: stock price;
    • X: strike price;
    • r: continuously compounded annual interest rate;
    • s: annual volatility;
    • T: time to maturity in days, which is an integer, and there are 365 days in a year;
    • H: up-and-out barrier, where H > S and H > X;
    • n: number of time steps in T, which is an integer.
    Output:
    • The price of the up-and-out barrier call option.
    • The price of the up-and-out barrier put option.
    • The price of the up-and-in barrier call option.
    • The price of the up-and-in barrier put option.
    For example, if S = 100, X = 110, r = 0.03, s = 0.3, T = 60, H = 120, and n = 100, the outputs are 0.311069, 11.083348, 1.370665, and 0.057256. Input Format (for Python codes, replace your student ID with uppercase): "python3 F08922011_HW_3.py 100 110 0.03 0.3 60 120 100". Output Format: "0.311069, 11.083348, 1.370665, 0.057256". Please send your source (and executable) code and a brief explanation txt file (if the code is not written in Python, describe how to run it) using NTU COOL before 08:00 AM 2025 May 9. No late submissions will be accepted. Compress all files into a single zip file, and name it ID_HW_i.zip, where ID is your student ID in uppercase and i is the number of the homework (example: F08922011_HW_3.zip). If the code is not written in Python, you may be asked to demonstrate your code to TA 許家豪 and you still have to submit the files before the deadline.
  12. Write a binomial-trinomial tree program to price double-barrier options. Note that the tree must match the barriers. Inputs:
    • S: stock price;
    • X: strike price;
    • r: continuously compounded annual interest rate;
    • s: annual volatility;
    • T: time to maturity in days, which is an integer, and there are 365 days in a year;
    • H: up-and-out barrier, where H > S and H > X;
    • L: down-and-out barrier, where L < S and L < X;
    • k: 2k represents the number of up steps from L to H, and is an integer as shown on page 776 of the course slides.
    Output:
    • The price of the double-barrier barrier call option.
    • The delta of the double-barrier barrier call option (caluclated by S × 1.01 and S × 0.99).
    • The price of the double-barrier barrier put option.
    • The delta of the double-barrier barrier put option (caluclated by S × 1.01 and S × 0.99).
    For example, if S = 95, X = 100, r = 0.10, s = 0.25, T = 365, H = 140, L = 90, and k = 50, the example outputs are 1.457183, 0.253302, 0.040884, and 0.007052. Input Format (for Python codes, replace your student ID with uppercase): "python3 F08922011_HW_4.py 95 100 0.10 0.25 365 140 90 50". Output Format: "1.457183, 0.253302, 0.040884, 0.007052". Please send your source (and executable) code and a brief explanation txt file (if the code is not written in Python, describe how to run it) using NTU COOL before 08:00 AM 2025 June 6. No late submissions will be accepted. Compress all files into a single zip file, and name it ID_HW_i.zip, where ID is your student ID in uppercase and i is the number of the homework (example: F08922011_HW_4.zip). If the code is not written in Python, you may be asked to demonstrate your code to TA 許家豪 and you still have to submit the files before the deadline.
  13. TBA
  14. Write a program for loan amortization swapping. Consider an n1-year, V-dollar loan at an r1 interest rate. At the end of year n2 (n2 < n1), however, there is an opportunity to swap the loan (i.e., the remaining principal) into a new loan with an r2 interest rate for the remaining n1-n2 years, of course under a new amortization. An F-dollar fee is charged at the end of year n2 if the loan is swapped. Both loans have the same number of payments per annum, m. Inputs:
    • V: original loan amount in dollars;
    • m: number of payments per annum, an integer;
    • n1: duration of the original loan in years, an integer;
    • r1: annual interest rate of the original loan, compounded m times per annum;
    • n2: the year that loan swapping is possible;
    • r2: annual interest rate of the new loan, also compounded m times per annum;
    • F: swapping fee.
    Outputs:
    • total principal paid in the first n2 years;
    • total interest paid in the first n2 years;
    • total interest paid from the end of year n2 (excluded) to the end of year n1 if the loan is not swapped (so the r1 interest rate is maintained);
    • total interest paid from the end of year n2 (excluded) to the end of year n1 if the loan is swapped to the new r2 interest rate;
    • the IRR for the whole n1 years (the fee F considered) if the loan is swapped;
    • does swapping the loan lower the IRR? Answer 1 for yes, 0 for no difference, and -1 for no.
    For example, if V = 1000000, m = 12, n1 = 2, r1 = 0.060, n2 = 1, r2 = 0.025, F = 888, the outputs are 485041.840313, 46805.482720, 16889.163346, 6999.998244, 0.051895, 1. Input format (for Python codes): "python3 F08922011_HW_1.py 1000000 12 2 0.060 1 0.025 888". Output format: "485041.840313, 46805.482720, 16889.163346, 6999.998244, 0.051895, 1". Please send your source (and executable) code and a brief explanation txt file (if the code is not written in Python, describe how to run it) using NTU COOL before 08:00 AM of March 22, 2024. No late submissions will be accepted. Compress all files into a single zip file, and name it ID_HW_i.zip, where ID is your student ID in uppercase and i is the number of the homework (example: F08922011_HW_1.zip). If the code is not written in Python, you may be asked to demonstrate your code to TA 許家豪 and you still have to submit the files before the deadline.
  15. Write a binomial tree program to price Bermudan put options, where early exercise is only allowed on specific dates. Inputs:
    • S: stock price;
    • X: strike price;
    • r: continuously compounded annual interest rate;
    • s: annual volatility;
    • T: time to maturity in days, which is an integer and also an exercise date;
    • m: number of periods per day for the tree, an integer;
    • E: early exercise dates from now, a list of integers.
    Output: The price of the Bermudan put option. For example, if S = 100, X = 110, r = 0.03, s = 0.3, T = 60, m = 5, and E = [10, 20, 30, 40, 50], the output is 11.248139. Input format (for Python codes, replace your student ID with uppercase): "python3 F08922011_HW_2.py 100 110 0.03 0.3 60 5 10 20 30 40 50". Output format: "11.248657". Please send your source (and executable) code and a brief explanation txt file (if the code is not written in Python, describe how to run it) using NTU COOL before 08:00 AM (GMT+8) 2024 April 19. No late submissions will be accepted. Compress all files into a single zip file, and name it ID_HW_i.zip, where ID is your student ID in uppercase and i is the number of the homework (example: F08922011_HW_2.zip). If the code is not written in Python, you may be asked to demonstrate your code to TA 許家豪 and you still have to submit the files before the deadline.
  16. Write a trinomial tree program to price a up-and-out barrier put. The trinomial tree must match the barrier. Inputs:
    • S: stock price;
    • X: strike price;
    • r: continuously compounded annual interest rate;
    • s: annual volatility;
    • T: time to maturity in days, which is an integer, and there are 365 days in a year;
    • H: up-and-out barrier;
    • n: number of time steps in T, which is an integer.
    Output: The price of the up-and-out barrier put option. For example, if S = 100, X = 110, r = 0.03, s = 0.3, T = 60, H = 120, and n = 100, the output is 11.089643. Input Format (for Python codes, replace your student ID with uppercase): "python3 F08922011_HW_3.py 100 110 0.03 0.3 60 120 100". Output Format: "11.089643". Please send your source (and executable) code and a brief explanation txt file (if the code is not written in Python, describe how to run it) using NTU COOL before 08:00 AM 2024 May 10. No late submissions will be accepted. Compress all files into a single zip file, and name it ID_HW_i.zip, where ID is your student ID in uppercase and i is the number of the homework (example: F08922011_HW_3.zip). If the code is not written in Python, you may be asked to demonstrate your code to TA 許家豪 and you still have to submit the files before the deadline.
  17. Write a least-squares Monte Carlo program to price an American-style Asian put, and use 1, x, x2 as the basis functions. Note that the put's payoff, when exercised early, uses the running average. Output its price and delta. Inputs:
    • S: stock price, which is a float;
    • X: strike price, which is a float;
    • T: time to maturity in days, which is an integer, and there are 365 days in a year;
    • r: continuously compounded annual interest rate, which is a float;
    • s: annual volatility, which is a float;
    • n: number of time steps in T, which is an integer;
    • N: number of simulation paths, which is an integer.
    Output: (1) Price of the put; (2) Delta of the put (caluclated by S × 1.01 and S × 0.99). For example, if S = 100, X = 100, T = 365, r = 0.05, s = 0.3, n = 100, and N = 10000, the example outputs are 5.483093 and -0.407075. Note that Input Format (for Python codes, replace your student ID with uppercase): "python3 F08922011_HW_4.py 100 100 365 0.05 0.3 100 10000". Output Format: "5.483093, -0.407075". Please send your source (and executable) code and a brief explanation txt file (if the code is not written in Python, describe how to run it) using NTU COOL before 08:00 AM 2024 June 7. No late submissions will be accepted. Compress all files into a single zip file, and name it ID_HW_i.zip, where ID is your student ID in uppercase and i is the number of the homework (example: F08922011_HW_4.zip). If the code is not written in Python, you may be asked to demonstrate your code to TA 閮勗振鞊?and you still have to submit the files before the deadline.

Enrollments