CS1411 — Exam 1 Study Guide

A4. Turtle Triangle

Create the design using turtle graphics. Use speed(), penup(), pendown(), goto(…, …), fillcolor(), begin_fill(), end_fill(), done().

The figure is a large unfilled (outline-only) triangle with a solid blue triangle nested inside it, apex up, both sharing the same bottom line — the inner triangle is the outer one at half scale, centred.

import turtle

SIDE = 200
HALF_SIDE = SIDE / 2
HEIGHT = SIDE * 0.8660254

turtle.speed(0)
turtle.hideturtle()

turtle.penup()
turtle.goto(-HALF_SIDE, -HEIGHT / 2)
turtle.pendown()

for i in range(3):
    turtle.forward(SIDE)
    turtle.left(120)

turtle.penup()
turtle.goto(-HALF_SIDE / 2, -HEIGHT / 2)
turtle.pendown()

turtle.fillcolor("blue")
turtle.begin_fill()

for i in range(3):
    turtle.forward(HALF_SIDE)
    turtle.left(120)

turtle.end_fill()

turtle.done()

Two things the professor listed that are easy to forget: the turn is 120° (exterior angle of an equilateral triangle, 360 / 3) and the fill must be wrapped in begin_fill() … end_fill(). No posted solution exists for this one — this is my reconstruction of the sheet's figure.

A5. 4 Circles

Create the design using Python's Turtle graphics.

Four filled circles in a 2×2 grid, each touching its neighbours: top-left green, top-right blue, bottom-left yellow, bottom-right red.

import turtle

RADIUS = 50

turtle.speed(0)
turtle.penup()

turtle.goto(-RADIUS, 0)
turtle.pendown()
turtle.fillcolor("green")
turtle.begin_fill()
turtle.circle(RADIUS)
turtle.end_fill()

turtle.penup()
turtle.goto(RADIUS, 0)
turtle.pendown()
turtle.fillcolor("blue")
turtle.begin_fill()
turtle.circle(RADIUS)
turtle.end_fill()

turtle.penup()
turtle.goto(-RADIUS, -2 * RADIUS)
turtle.pendown()
turtle.fillcolor("yellow")
turtle.begin_fill()
turtle.circle(RADIUS)
turtle.end_fill()

turtle.penup()
turtle.goto(RADIUS, -2 * RADIUS)
turtle.pendown()
turtle.fillcolor("red")
turtle.begin_fill()
turtle.circle(RADIUS)
turtle.end_fill()

turtle.hideturtle()
turtle.done()

Geometry worth memorising: with the heading pointing east, circle(r) puts the circle's centre r units to the left (north) of the starting point, so the start points above are the bottoms of each circle. Verified against the sheet's figure: the four centres come out at (±50, ±50) with radius 50 — tangent.

A6. Roll Dice

Simulate 2 users rolling dice. Two variables holding values between 2 and 12. Output each player's roll, then who won or that it was a tie.

import random

player1 = random.randint(2, 12)
player2 = random.randint(2, 12)

print("Player 1: ", player1)
print("Player 2: ", player2)

if player1 > player2:
    print("Player 1 Wins")
elif player2 > player1:
    print("Player 2 Wins")
else:
    print("Tie")

The trap: the sheet says 2 to 12, so it is randint(2, 12), not randint(1, 12) and not randint(1, 6). Three sample runs on the sheet (6/5 → P1, 6/12 → P2, 8/8 → Tie) all reproduce.

A7. Roman Numeral Converter

Ask the user for a number 1–10. Use if: / elif: / else: to display the Roman numeral. Input validation: do not accept a number less than 1 or greater than 10.

number = int(input("Input an integer from the range: 1 through 10: "))

if number == 1:
    print("The Roman Numeral Equivalent is: I")
elif number == 2:
    print("The Roman Numeral Equivalent is: II")
elif number == 3:
    print("The Roman Numeral Equivalent is: III")
elif number == 4:
    print("The Roman Numeral Equivalent is: IV")
elif number == 5:
    print("The Roman Numeral Equivalent is: V")
elif number == 6:
    print("The Roman Numeral Equivalent is: VI")
elif number == 7:
    print("The Roman Numeral Equivalent is: VII")
elif number == 8:
    print("The Roman Numeral Equivalent is: VIII")
elif number == 9:
    print("The Roman Numeral Equivalent is: IX")
elif number == 10:
    print("The Roman Numeral Equivalent is: X")
else:
    print("The number is not valid")

This is Adrien's own submitted file, so it already matches what the professor accepted. Note his wording: the sheet's "input validation" for this lab is done with the else branch printing The number is not valid — no loop. Verified: 1–10 all correct, 30 → The number is not valid.

A8. Turtle Exercise – Hit the Target (Program 3-9)

The base program draws a target square at (100, 250)–(125, 275), asks for an angle and a force, launches force * 30 pixels and reports a hit or a miss. The class modification adds hints ("Try a greater angle", "Use less force").

Base program — reproduced from the class starter file (identical to textbook Program 3-9):

import turtle

SCREEN_WIDTH = 600
SCREEN_HEIGHT = 600
TARGET_LLEFT_X = 100
TARGET_LLEFT_Y = 250
TARGET_WIDTH = 25
FORCE_FACTOR = 30
PROJECTILE_SPEED = 1
NORTH = 90
SOUTH = 270
EAST = 0
WEST = 180

turtle.setup(SCREEN_WIDTH, SCREEN_HEIGHT)

turtle.hideturtle()
turtle.speed(0)
turtle.penup()
turtle.goto(TARGET_LLEFT_X, TARGET_LLEFT_Y)
turtle.pendown()
turtle.setheading(EAST)
turtle.forward(TARGET_WIDTH)
turtle.setheading(NORTH)
turtle.forward(TARGET_WIDTH)
turtle.setheading(WEST)
turtle.forward(TARGET_WIDTH)
turtle.setheading(SOUTH)
turtle.forward(TARGET_WIDTH)
turtle.penup()

turtle.goto(0, 0)
turtle.setheading(EAST)
turtle.showturtle()
turtle.speed(PROJECTILE_SPEED)

angle = float(input("Enter the projectile's angle: "))
force = float(input("Enter the launch force (1-10): "))

distance = force * FORCE_FACTOR

turtle.setheading(angle)
turtle.pendown()
turtle.forward(distance)

if (turtle.xcor() >= TARGET_LLEFT_X and
    turtle.xcor() <= (TARGET_LLEFT_X + TARGET_WIDTH) and
    turtle.ycor() >= TARGET_LLEFT_Y and
    turtle.ycor() <= (TARGET_LLEFT_Y + TARGET_WIDTH)):
    print('Target hit!')
else:
    print('You missed the target.')

turtle.done()

Verified by execution: angle 68 / force 9 — the combination the sheet gives as a winner — lands at (101.14, 250.34), inside the box. angle 45 / force 3 lands at (63.6, 63.6), a clean miss.

The hint version adds, in the else: branch:

        if turtle.xcor() < TARGET_LLEFT_X:
            print('Try a greater angle.')
        elif turtle.xcor() > (TARGET_LLEFT_X + TARGET_WIDTH):
            print('Try a smaller angle.')
        if turtle.ycor() < TARGET_LLEFT_Y:
            print('Use more force.')
        elif turtle.ycor() > (TARGET_LLEFT_Y + TARGET_WIDTH):
            print('Use less force.')

The extended version (sheet Turtle Target Loop, lab due Sep 22) wraps the whole prompt + launch in a while loop that repeats until the box test passes — see codes/turtle_target_loop.py. If the exam asks for the looped version, that is the shape: initialise a flag, loop while not hit, re-goto(0, 0) each try.

A9. Loop Exercise 0 — Input validation and even numbers

Prompt for a positive integer num; keep prompting until the input is positive; then loop to output every even integer from 0 up to but not including num. Sample run: -1, 0, 10 → Output integers -> then 0 2 4 6 8 (one per line).

num = int(input("Input a positive integer "))

while num <= 0:
    num = int(input("Input a positive integer "))

print("Output integers ->")

for i in range(0, num, 2):
    print(i)

Two loops, two purposes — he will be looking for exactly this: a while for validation and a for with a step for the output. Note range(0, num, 2) stops before num. Verified: -1, 0, 10 gives 0 2 4 6 8.

C1. What is the purpose of the ALU and the CU? (the review sheet names this one specifically)

• ALU — Arithmetic Logic Unit: performs the arithmetic operations (add, subtract, multiply, divide) and the logical operations (comparisons such as equal / greater / less, and AND/OR/NOT) on the data. It has direct access to RAM for its inputs and results.
• CU — Control Unit: directs and coordinates the rest of the computer. It fetches and decodes each instruction, tells the ALU, memory and I/O devices what to do, and keeps the steps of a program happening in the right sequence and at the right time. It does not itself do arithmetic.
• One-line contrast to memorise: the ALU does the work; the CU tells everyone else what to do.

Sources: the professor's own slide Computer Organization Overview (Canvas, Lecture Notes module 516318) labels the CPU as ALU – Arithmetic Logic Unit / CU – Control Unit; the review sheet links geeksforgeeks.org/computer-science-fundamentals/difference-between-alu-and-cu/, which states: "ALU … performs all the basic arithmetic (addition, subtraction, multiplication, and division) operations and logical operations" and "the main work of the CU is to tell the most efficient method to work … It informs the ALU, I/O devices, and the RAM how to respond to the command that has been sent to the processor."

C2. The fetch-decode-execute cycle (textbook §1.4, Figure 1-16 — also on the professor's slide)

"When a CPU executes the instructions in a program, it is engaged in a process that is known as the fetch-decode-execute cycle. This cycle, which consists of three steps, is repeated for each instruction in the program."

1. Fetch — read the next machine-language instruction from memory into the CPU.
2. Decode — work out which operation the instruction is asking for.
3. Execute — perform the operation. The textbook's own review question on this: "In the ______ part of the fetch-decode-execute cycle, the CPU determines which operation it should perform" → decode. Related wording to know: a program is nothing more than a list of instructions that cause the CPU to perform operations; those instructions are written in machine language (binary); the complete set of instructions a CPU can execute is its instruction set.

C3. Binary, bits and bytes (textbook §1.3)

• A bit is a single binary digit; a bit that is off represents 0; 1 = high voltage, 0 = low voltage (professor's slide).
• 8 bits = 1 byte, "enough memory to store a letter of the alphabet or a small number."
• ASCII = a set of 128 numeric codes for English letters, punctuation and other characters. Unicode = the extensive encoding scheme that can represent characters for many languages.
• Negative numbers are stored with two's complement; real numbers with floating point.
• Digital images are made of pixels.

C4. Memory and storage

• Main memory / RAM is volatile and is where a program must be copied before the CPU can execute it ("a program … has to be copied into main memory, or RAM, each time the CPU executes it").
• Secondary storage keeps data when the power is off.
• An input device collects data and sends it to the computer; a video display is an output device.

C5. Structures and loop vocabulary (Chapter 3–4 slides)

• Sequence structure: statements execute in the order they appear.
• Decision / selection structure: an action happens only if a condition is true; the diamond in a flowchart is the true/false test.
• Repetition structure: repeats as long as a condition holds.
• while = condition-controlled (pretest) — it can execute zero times.
• for = count-controlled — iterates once per item in a sequence.
• Infinite loop: a loop with no way of stopping (the slide deck: "Occurs when programmer forgets to include stopping code in the loop").
• Sentinel: "a special value that marks the end of a sequence of items".
• Input validation: "inspecting input before it is processed by the program" — repeat while the input is bad.
• Nested loop: a loop inside another loop; the inner loop completes all of its iterations for each single iteration of the outer loop.

C6. Python language details that show up as short questions

• input() returns a string; convert with int() / float() when you need math.
• = assigns, == compares, != is "not equal".
• In an if/elif/else, Python tests the branches in order and stops at the first true one — that is exactly why the Roman-numeral elif chain works.
• Comments start with #. The syllabus itself asks students to note which IDE they used in a comment at the top of a program.
• The walrus operator := assigns and returns the value (print(num := 99)), and is used in the book's newer input-validation loops — while (score := int(input('Enter your score: '))) < 0:. Lower priority, but it is on the Chapter 3 and 4 slides.

C7. Software development life cycle (professor's System Development Life Cycle note)

System Request → Planning → Analysis → Design → Implementation → Maintenance. Planning = feasibility study (is it possible? is it profitable?); Analysis = the list of requirements; Design = how each requirement gets implemented; Implementation = code it and test it; Maintenance = updates, security, fixing bugs, new features.

All outputs below were produced by actually running the programs.

D1

n = 0
while n < 5:
    print(f'Inside the loop, the value of n is {n}.')
    n += 1

→ Inside the loop, the value of n is 0. through … is 4. (5 lines, 0→4).

D2

count = 10
while count > 0:
    print(count)
    count -= 1
print('Blastoff!')

→ 10 9 8 7 6 5 4 3 2 1 then Blastoff!

D3

for name in ['Winken', 'Blinken', 'Nod']:
    print(name)

→ Winken, Blinken, Nod

D4

for n in range(3):
    if n == 5:
        print('Breaking out of the loop.')
        break
    print(n)
else:
    print(f'After the loop, n is {n}.')

→ 0, 1, 2, After the loop, n is 2. (no break happened, so else runs)

D5

n = 100
while n < 5:
    print(n)
    n += 1
else:
    print(f'Now n is {n}.')

→ Now n is 100. only — the body never ran, else still ran.

D6

for outer in range(5):
    for inner in range(20):
        print('*', end='')
        if inner == 3:
            break
    print()

→ five lines, each **** (10 stars per row would be the trap if you assumed break exits both loops).

D7

BASE_SIZE = 8
for r in range(BASE_SIZE):
    for c in range(r + 1):
        print('*', end='')
    print()

→ 8 lines: 1, 2, 3, 4, 5, 6, 7, 8 stars.

D8

n = 0; while n < 10: n += 1 → prints nothing at all (there is no print inside; the loop just counts). A favourite trick question.

B1. Nested loops — star patterns (Chapter 4, explicitly named on the sheet)

Write nested loops that print a right triangle of * with 8 rows, growing by one star each row.

BASE_SIZE = 8

for r in range(BASE_SIZE):
    for c in range(r + 1):
        print('*', end='')
    print()

Output (verified): *, **, ***, … ********. The pair to remember: the inner loop controls the row length, the outer loop controls how many rows, and print() with no arguments ends the row.

Same idea, staircase: 6 steps, each a single # preceded by a growing run of spaces.

NUM_STEPS = 6

for r in range(NUM_STEPS):
   for c in range(r):
      print(' ', end='')
   print('#')

Ask the user for rows and columns, then print a rectangle of stars.

rows = int(input('How many rows? '))
cols = int(input('How many columns? '))

for r in range(rows):
    for c in range(cols):
        print('*', end='')
    print()

Key rule straight from the slide deck: "Total number of iterations in nested loop = number of iterations of inner loop X number of iterations of outer loop."

B2. for vs while vs range() (Chapter 4)

Print a table of the numbers 1–10 and their squares.

print('Number\tSquare')
print('--------------')

for number in range(1, 11):
    square = number**2
    print(f'{number}\t{square}')

Use a while loop as a count-controlled loop: print the value of n for n = 0..4.

n = 0
while n < 5:
    print(f'Inside the loop, the value of n is {n}.')
    n += 1

The slide deck names the three obligations of a count-controlled while: initialise, compare, update (here n = 0, n < 5, n += 1). Expect a question where one of the three is missing — that's the bug.

range() rules to have cold: one argument = ending limit; two arguments = start, end; three = start, end, step; and the ending limit is never included.

B3. Input validation loop (Chapter 4 + used in half the labs)

Keep asking for a wholesale cost until it is not negative, then print the retail price at a 2.5 markup.

MARK_UP = 2.5
another = 'y'

while another == 'y' or another == 'Y':
    wholesale = float(input("Enter the item's wholesale cost: "))

    while wholesale < 0:
        print('ERROR: the cost cannot be negative.')
        wholesale = float(input('Enter the correct ' +
                                'wholesale cost: '))

    retail = wholesale * MARK_UP

    print(f'Retail price: ${retail:,.2f}')

    another = input('Do you have another item? ' +
                    '(Enter y for yes): ')

This is the book's retail_with_validation.py, and it is the template for Loop Exercise 0 and the Lottery Part 2 lab: an outer "do it again?" loop, an inner validation loop.

B4. Sentinel / running total / average (Chapter 4)

A sentinel value ends the loop; add up the inputs until then; then report the total (and average).

The pattern: prime the read before the loop, test the sentinel in the while condition, and read again at the bottom of the loop body. The book's sum_numbers.py / commission.py do exactly that, and count_commission.py shows the counter-variable version. Expect a question that gives a starting template with only the bottom read missing — forgetting it produces an infinite loop, which the slide deck calls out by name.

B5. break, continue, and the loop else (Chapter 4)

What does this print, and why does the else clause run?

n = 100
while n < 5:
    print(n)
    n += 1
else:
    print(f'Now n is {n}.')

Verified output: just Now n is 100. — the loop body never executed but else still runs, because else on a loop runs whenever the loop ends without break. Contrast with for r in range(3): if r == 5: break — no break happens, so else also runs and prints After the loop, n is 2. Only break suppresses a loop's else.

break inside nested loops:

for outer in range(5):
    for inner in range(20):
        print('*', end='')
        if inner == 3:
            break
    print()

Verified output: five lines of ****. break leaves only the loop it is in — the outer loop keeps going, which is the mistake the book flags.

B6. Random numbers (Chapter 2/5 material the class covered with demo_random_number_generation.py)

The professor's demo uses six functions — be able to say what each returns: random.randint(1, 100) (int, both ends included), random.random() (float 0.0–1.0), random.uniform(1.5, 10.5) (float in a range), random.choice(list) (one item), random.sample(list, 3) (3 items, no repeats), random.shuffle(list) (reorders in place).

B7. Decisions — if / elif / else, string comparison, ranges

Convert a numeric score to a letter grade with an if-elif-else chain (book grader.py).

Test whether a value is inside a numeric range — slide deck: use and for inside (x >= 10 and x <= 20), use or for outside (x < 10 or x > 20).

Put two names in alphabetical order with if name1 < name2: — strings compare character by character using ASCII, and string comparison is case sensitive.

B8. Formatting and arithmetic (Chapter 2)

• f'{value:,.2f}' gives thousands separators and 2 decimals ($1,234.57).
• //, %, **, and the augmented forms += -= *= /= //= %=.
• The type-conversion trap: input() always returns a string. input('Enter a number: ') * 2 repeats the string; you need int(...) or float(...) first.