9-1 Rectangle

Store dimensions in public attributes width and height, with this interface:

class Rectangle:
    def __init__(self, width: float, height: float) -> None: ...
    def area(self) -> float: ...
    def perimeter(self) -> float: ...
    def is_square(self) -> bool: ...
    def scale(self, factor: float) -> None: ...

Contract:

Dimensions and scale factors must be finite and positive. Zero, negative values, NaN, and either infinity are invalid; construction or scaling raises ValueError.
Area, perimeter, and square queries preserve dimensions. is_square() compares the two stored dimensions; approximate geometric equality is not required here.
scale(factor) updates both dimensions in place and returns None, not a new rectangle.
The resulting dimensions must also remain finite and positive. If floating-point scaling produces infinity or zero, raise ValueError and retain both old dimensions.
Ordinary tests use representable areas and perimeters. Real parameters arrive as integers or floats, not other object types.

r = Rectangle(3, 4)
r.area()             → 12
r.perimeter()        → 14
r.is_square()        → False
r.scale(2)           → None
r.width, r.height    → 6, 8
r.area()             → 48

Test separate instances, squares, invalid starting dimensions, successful scaling, and full state preservation after failure. Compare floating results with an appropriate tolerance.

The A card explains this in-place contract and contrasts an alternative returning a new object. The explanation cannot choose that alternative while the code violates this entry’s required behavior.

Code entry: w09-rectangle.

9-2 Stack

Implement last-in, first-out storage for each instance:

class Stack:
    def __init__(self) -> None: ...
    def push(self, item: int) -> None: ...
    def pop(self) -> int: ...
    def peek(self) -> int: ...
    def is_empty(self) -> bool: ...
    def size(self) -> int: ...

Push appends an integer to the top and returns None.
Pop removes and returns the top; peek returns it without removal.
Empty pop and peek both raise IndexError and leave the stack empty. Do not return None or rely on the evaluator to check emptiness first.
A new stack is empty with size zero. Operations on two instances must not affect each other.

s.push(7); s.push(9)
s.peek()     → 9
s.size()     → 2
s.pop()      → 9
s.pop()      → 7
s.is_empty() → True
s.pop()      → IndexError

On the A card, compare returning None, raising an exception, and requiring a caller precondition. Those are real design alternatives; this code entry uses one fixed exception contract.

Code entry: w09-stack.

9-3 WordCounter

class WordCounter:
    def __init__(self) -> None: ...
    def add(self, word: str) -> None: ...
    def get(self, word: str) -> int: ...
    def total(self) -> int: ...
    def most_common(self, n: int) -> list[tuple[str, int]]: ...

Treat the supplied string as one exact key. Do not tokenize, strip punctuation, or change case. The empty string is also a valid key.
Unseen keys have count zero. Total is the sum of occurrences, not the number of distinct keys.
Return at most n (word, count) pairs, count descending and ties ascending in Python string order. For n=0 return an empty list; a larger n returns all available pairs.
n is a nonnegative integer. Negative n raises ValueError; noninteger n is outside these tests.
Queries and sorting preserve counts. Every instance needs its own dictionary.
A named sort-key function is sufficient; lambda is not needed before its later dedicated treatment.

Add "pear", "apple", "pear", "banana" in that order.
get("pear")      → 2
get("missing")   → 0
total()          → 4
most_common(3)   → [("pear", 2), ("apple", 1), ("banana", 1)]

The A card records an actual two-instance experiment: operations, expected observations, actual observations, and a conclusion. “Tests passed” is not a substitute for the observations.

Code entry: w09-word-counter.

9-4 Temperature

Store Celsius in the nonpublic field self._celsius:

class Temperature:
    def __init__(self, celsius: float) -> None: ...
    def celsius(self) -> float: ...
    def fahrenheit(self) -> float: ...
    def kelvin(self) -> float: ...
    def set_celsius(self, value: float) -> bool: ...

Values must be finite real numbers at least −273.15°C. Inputs arrive as integers or floats, not other object types.
Invalid initialization raises ValueError.
An invalid update returns False without replacing the old value. An accepted update stores the new value and returns True.
Queries preserve state. Fahrenheit is c * 9 / 5 + 32; Kelvin is c + 273.15.
Do not store an invalid candidate first and repair it later.

t = Temperature(25)
t.celsius()        → 25
t.fahrenheit()     → 77
t.kelvin()         → 298.15
t.set_celsius(-300) → False
t.celsius()        → 25
t.set_celsius(100)  → True

Exercise the exact lower boundary, values below it, NaN/infinity, all three queries after rejection, and separate instances. Explain why construction and updates need validation and why an underscore does not enforce it.

Code entry: w09-temperature.

A design and verification card

Text entry: w09-a-design-notes. Four responses carry 2 staff points each:

Mutation or new result: explain Rectangle’s contract and the return values and alias effects of the alternative.
Empty-stack policy: compare None, an exception, and a caller precondition; justify consistency with this IndexError interface.
Instance isolation: give the operations and expected/actual results for two WordCounters.
Valid state: provide invalid-constructor and failed-setter evidence for Temperature, including state before/after and the meaning of the underscore.

A separate zero-point AI declaration records tool/version, requested task, adopted or changed content, and verification evidence. State nonuse explicitly. A generated answer or an unsupported personal conclusion is not test evidence.

Homework 3

Sign in

Create account