Ludium
Sign In
Introduction to Computer Science using Python
Computation & Python Basics
01Algorithms as Recipes02The Six Operations Behind Every Program03Primitives, Syntax, and Semantics04Objects, Types, and Type Casting05Expressions, Operators, and Types06Assignment vs. EqualityProblem set0/10Practice∞
01Objects, Names, and Assignment02String Concatenation, Repetition, and len()03String Indexing and Slicing04String Immutability and the print() Function05User Input, Type Conversion, and f-strings06Comparisons, Booleans, and Logical Operators07Conditionals: if, elif, and elseProblem set0/10Practice∞
Control Flow & Iteration
01Conditional Branching: if, elif, and else02Iteration and the While Loop03While Loops, Counters, and Infinite Loops04While Loop Variables and Running Products05The for Loop and range()06The Accumulator Pattern and range()Problem set0/10MIT problem set0/2Practice∞
01The break Statement: Exiting a Loop Early02Looping Over Strings and the in Operator03Guess-and-Check: Exhaustive Enumeration04for Loops, Boolean Flags, and Cube Roots05Nested Loops and Brute-Force Search06Floats, Binary, and Floating-Point ErrorProblem set0/10Practice∞
Numbers & Algorithms
01Converting Integers to Binary (and Negatives)02Why 0.1 Can't Be Stored: Fractions in Binary03How Floats Are Stored, and Why You Never Use ==04Successive Approximation and the Loop That Never EndsProblem set0/10Practice∞
01Why Approximation Search Hits a Wall02Halving the Search Space at Every Step03Coding Bisection Search for Square Roots04Fixing Bisection Search for Numbers Below One05Newton-Raphson: Sliding Down the Tangent LineProblem set0/10MIT problem set0/1Practice∞
Functions & Abstraction
01Abstraction and Decomposition: Why Your Phone Is a Black Box02What a Function Really Is: The Specification and Its Four Parts03Writing Your First Function: From a Sentence to is_even04How a Function Call Becomes Its Value: Parameters vs. Arguments05Return vs. Print: The Mysterious None, and Functions in Real Code06Building sum_odds: Plan on Paper, Then Catch the Off-by-One BugProblem set0/10Practice∞
Scope & Higher-Order Functions
01return vs. print, and the Hidden None That Reveals a Bug02Turning Bisection Square Root Into a Reusable Function03Environments and Scope: The Rule Behind UnboundLocalError04A Function Is an Object: Naming, Passing, and Tracing Calls05Higher-Order Functions: Building apply(criteria, n)Problem set0/10Practice∞
Lambdas & Sequences
01Writing Anonymous Functions With Lambda02Tracing Nested Calls with the Environment Model03Tuples: An Ordered, Mixed-Type Sequence04Why Tuples Are Immutable: Nesting and Iteration05Tuple Unpacking: One-Line Swaps and Many Returns06The Star (*args), Lists, and Pythonic LoopsProblem set0/10MIT problem set0/3Practice∞
Mutating Lists
01Lists Mutate, Tuples Don't: The Name vs the Object02append: Growing a List and the None Trap03Dot Notation: Building and Filtering Lists04split and join: Converting Between Strings and Lists05sort vs. sorted: Mutate in Place or Return a New List06Writing Functions That Mutate a List In Place07Appending While Looping, and extend vs append08Reassignment vs Mutation, Proven with id()Problem set0/10MIT problem set0/1Practice∞
Aliases & Copies
01Cloning with L[:]: Mutating a List In Place02del, pop, and remove: Three Ways to Delete03The Loop That Skips: Removing While Iterating04Aliases vs Clones: Why L2 = L1 Is Not a Copy05Shallow vs Deep Copy: copy.copy and copy.deepcopyProblem set0/10Practice∞
Comprehensions, Testing & Debugging
01List Comprehensions: Your Build-a-List Loop in One Line02Reading Any Comprehension: Iterable, Expression, Condition03Default Parameters: Defaults Last, Keywords at the Call Site04Returning a Function Object: return g, Not return g()05Catching a Returned Function: Two Names, One Object06Unit, Regression, and Integration Testing07Black Box vs Glass Box: Where Test Cases Come From08Debugging by Bisection: Print Statements as EvidenceProblem set0/10Practice∞
Exceptions & Assertions
01try and except: Catching an Exception Instead of Crashing02Named Exception Handlers, else, finally, and raise03raise ValueError and assert: Enforcing Your Docstring04One Empty List, Four Designs: Crash, None, Default, AssertProblem set0/10Practice∞
Dictionaries
01Why Lists Fail at Lookup: Parallel Lists and Nested Search02Dictionaries: Custom Keys, Curly Braces, and KeyError03Mutating a Dictionary: Add, Overwrite, del, and in04keys(), values(), items(): Three Windows Into a Dictionary05Hashing and Immutable Keys: Why a List Can't Be a Key06Case Study: Building a Word Frequency Dictionary07Ranking Words by Deleting Them: The Cost of MutationProblem set0/10MIT problem set0/8Practice∞
Recursion
01Multiplying With Only Addition: From Loops to a Smaller Copy02Writing mult_recur: Base Case, Recursive Step, and the Call Stack03Divide and Conquer: The Regrade Chain and Writing power_recur04Recursive Factorial Acted Out: Environments and When to RecurseProblem set0/10Practice∞
01fib_recur: Two Recursive Calls and an Exploding Call Tree02Memoization: One Dictionary Cuts 11 Million Calls to 6503Counting Basketball Scores: Three Base Cases, Three Branches04Recursion on Lists: Peel One Element, Trust the Rest05Debugging a Recursive Search: Print, Fix, and Return Types06Nested Lists: Flatten, Search, and Why Loops Fall Short07Reversing a List Recursively: The Brackets That Make It Legal08deep_rev: One Type Test Reverses Every LayerProblem set0/10MIT problem set0/3Practice∞
Classes & Objects
01Class vs Instance: The Blueprint Behind Every Object02Choosing Data and Behavior: Elevators, Employees, and Stacks03class Coordinate(object): Implementing a Type vs Using It04The __init__ Constructor: Why Every Method Starts With self05Creating Instances: Coordinate(3, 4), Dot Notation, and Memory06Methods and the Dot Operator: distance, and How self Gets BoundProblem set0/10MIT problem set0/3Practice∞
Composition & Dunder Methods
01Data Attributes vs Parameter Names: What self Guarantees02Returning a Value vs Mutating the Object: Writing to_origin03Composition and ValueError: A Circle Made of Coordinate Objects04Before the Dot Becomes self: Writing a SimpleFraction Class05Every Operator Is a Method: Meet Python's Dunder Names06The __str__ Method: You Decide What print Shows07Overloading * and float() for a Fraction Class08Inside reduce: a Nested gcd and the Branch That Returns an intProblem set0/10Practice∞
Inheritance
01Data and Procedural Attributes: Building the Animal Class02Getters, Setters and __str__: Why the Method Outlives the Attribute03Attribute Abuse From Outside, and a Dictionary of Animal Objects04make_animals: Walking Two Lists in Step to Build a List of Objects05Hierarchies and Subclasses: The Three Moves a Subclass Can Make06class Cat(Animal): Inheriting __init__ and the Chain Python Climbs07Overriding __init__: Person Calls Animal.__init__ By Name08Student, a Subclass of a Subclass, and the Rabbit Class Variable09__add__ and __eq__ on Rabbits: Operator Overloading With Shared IDsProblem set0/10MIT problem set0/5Practice∞
An Object-Oriented Case Study
01Designing a Workout Class: __init__ Makes Five Attributes From Three02Two State Dictionaries: __dict__ on the Class and on the Object03A Getter That Estimates: Class Variables, None, and datetime04parser.parse and Where a Class Variable Actually Lives05class RunWorkout(Workout): Inheritance and super().__init__06One __str__ in the Parent, Three Kinds of Workout Printing07A Subclass Where Its Parent Goes, and Positional Argument Order08Overriding get_calories: How Python Picks Which Method Runs09__eq__ With super(), and the Last Word on Building ClassesProblem set0/10MIT problem set0/4Practice∞
Program Efficiency
01Correct Isn't Fast: time.time() and Three Functions Built to Be Measured02Timing Nine Input Sizes, and Four Reasons the Seconds Measure the Machine03One Unit per Operation: Costing Three Functions by Hand, Then in Code04Ten Times the Input, a Hundred Times the Work: Reading Operation CountsProblem set0/10Practice∞
01A Finer Clock: time.perf_counter and a Runtime That Never Moves02Which Parameter Costs Time? compound, sum_of, and One Linear Shape03Brute Force, Bisection, or in: Timing Three Searches to 100 Million04A Loop Inside a Loop: the diameter Function and Quadratic Growth05Counting Operations: Exact Formulas and a Program That Counts Itself06Order of Growth: What to Measure, Which Input, and the Worst Case07Big O: An Upper Bound That Only Has to Hold Past the Crossover08Big Theta: Bounded From Both Sides, Keep Only the Dominant Term09Reading Theta Off the Loops: Two Laws and Six Complexity ClassesProblem set0/10Practice∞

Coding challenges on control flow: branching and loops — MIT problem set

Problem 1While Loop Variables and Running Products

Saving for a House: Months to the Down Payment

MIT 6.100L Introduction to CS and Programming Using Python, Fall 2022 · Problem set 1, 2) Part A: Saving for a House — ps1a.py · Dr. Ana Bell · CC BY-NC-SA 4.0 · MIT publishes no solution for this set; the worked solution is ours

Write the body of months_to_save(yearly_salary, portion_saved, cost_of_dream_home): MIT's Part A program, which finds the number of months it takes to save up for the down payment on your dream home.

No input() here. MIT's program asks the user for three numbers with input(). In the browser the starter wraps the program in a function instead, just as MIT's own tester does: the three parameters on the def line, yearly_salary, portion_saved and cost_of_dream_home, stand in for the three input() calls (in MIT's order) and already hold the numbers the user typed. Write your program between the def line and the final return months, using those three names exactly as you would have used the values input() returned. The last line, return months, hands your months back to the tests. Don't change the def line or the return line.

You have just graduated from MIT and have a job! You move to the Bay Area and decide that you want to start saving for a home. Houses are fairly expensive, so you start saving up for the down payment on your dream home.

Your goal is to find the number of months it takes to save up for a down payment. The cost of your down payment is calculated by multiplying the total cost of your dream house by the down payment percentage.

User Inputs. MIT's program asks the user to enter the following variables and cast them as floats, in the following order, at the beginning of the program, before declaring other variables. Here they are the function's parameters, already filled in:

  1. The starting yearly salary (yearly_salary)
  2. The portion of salary to be saved (portion_saved). This variable should be in decimal form (e.g. 0.1 for 10%).
  3. The cost of your dream home (cost_of_dream_home)

Writing the Program. You will need to determine how many months it will take given the following information:

  1. yearly_salary, as described above.
  2. portion_saved, as described above.
  3. cost_of_dream_home, as described above.
  4. portion_down_payment, the percentage of the total cost needed for a down payment. Assume portion_down_payment = 0.25 (25%).
  5. The amount that you have saved thus far is amount_saved, which starts at $0.
  6. You get an annual rate of return r. In other words, at the end of each month, you receive an additional amount_saved * (r/12) funds for your savings (the 12 is because r is an annual rate). Assume r = 0.05 (5%).
  7. At the end of each month, your savings increase by (1) a percentage of your monthly salary and (2) the monthly return on your investment. (Note: The investment amount used to calculate the monthly return is the amount you had saved at the start of each month.)

Output. Your program should store the number of months required to save for the down payment using a variable called months.

Notes

  • Be careful about values that represent annual amounts versus monthly amounts.
  • If the number of months your program returns is off by one, reread the highlighted (bold) text in items 6 and 7 above.
  • Assume that users enter valid inputs (e.g. no string inputs when expecting a float).

MIT's three test cases, as calls (each prints the months your function returns):

print(months_to_save(112000, .17, 750000))  # 97
print(months_to_save(65000, .20, 400000))  # 79
print(months_to_save(350000, .3, 10000000))  # 189

Adapted for the browser: MIT's three input() calls became the parameters of months_to_save (same names, same order), and the program returns months instead of printing Number of months: ....

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def months_to_save(yearly_salary, portion_saved, cost_of_dream_home):
    #########################################################################
    ## Initialize other variables you need (if any) for your program below ##
    #########################################################################


    ###############################################################################################
    ## Determine how many months it would take to get the down payment for your dream home below ##
    ###############################################################################################


    return months

Scratchpad— run any Python to test ideas
1
2
3
4
5
# Scratchpad — run any Python here to test ideas.
# Anything you write below stays separate from the problem's tests.

print("hello, world")

Python runtime ready in a moment
Python runtime ready in a moment
Visible tests · 3Examples — click to expand
?
MIT test case 1: yearly_salary 112000, portion_saved .17, cost_of_dream_home 750000
?
MIT test case 2: yearly_salary 65000, portion_saved .20, cost_of_dream_home 400000
?
MIT test case 3: yearly_salary 350000, portion_saved .3, cost_of_dream_home 10000000
Hidden tests · 3Bodies hidden — pass/fail only
?
Hidden test 1
?
Hidden test 2
?
Hidden test 3