Programming, problem solving, and algorithms

CPSC 203, 2026 W1

September 15, 2026

Announcements

• Results of course survey.

• Updates to CPSC 203 course website.

  • Logistics: TA office hours.
  • Syllabus: Course policy on AI use.
  • Schedule: Links to slides, videos, labs, POTWs, …

• Monitor (and post to) Piazza.

• POTW is available on PrairieLearn.

• Enroll in CPSC203 on PrairieTest.

  • Book your slot for the first examlet (Thur Oct 1 - Mon Oct 5).
  • Students with accommodations: If you cannot see your accommodation when you try to book a slot, email me.

• Show survey results.
• Show Syllabus GenAI update, and possibly logistics and schedule updates.

Today’s Plan…

• Correctness isn’t everything…
• Knitting
• Work / effort / complexity
• Simplicity / elegance / abstraction
• Colour (if we get to it)

Correctness isn’t Everything

Let’s Go Shopping (version 1)

define shopping_trip1(grocery_list: List[food_item])
                      -> pantry_list: List[food_item]:

  # List of food in the pantry so far.
  pantry_list = []

  for item_on_grocery_list in grocery_list:
    # Take paper with single item to the store.
    item_at_store = go_to_store(item_on_grocery_list)
    # Get the item from the shelf.
    item_in_cart = pick_at_store(item_at_store)
    # Bring the item home.
    item_at_home = return_from_store(item_in_cart)
    # Put the item away.
    pantry_list.append(put_in_pantry(item_at_home))

  return pantry_list

(define shopping-trip1 grocery-list
  (cond [(empty? grocery-list) '()],
        [else
          (cons (put-in-pantry
                  (return-from-store
                    (pick-at-store
                      (go-to-store (first grocery-list)))))
                (shopping-trip1 (rest grocery-list)))]))

I am being sloppy here by assuming that the helper functions can accept (and will return) either a single item or a list of items

If we have \(n\) items in our list, how long does this procedure take?

• How long to go_to_store?
• How long to pick_at_store?
• How long to return_from_store?
• How long to put_in_pantry?

Let’s Go Shopping (version 2)

define shopping_trip2(grocery_list: List[food_item])
                      -> pantry_list: List[food_item]:

  # Take piece of paper with list to the store.
  grocery_list_at_store = go_to_store(grocery_list)

  # Get all items on the list into the cart.
  cart_list = []
  for item_at_store in grocery_list_at_store:
    cart_list.append(pick_at_store(item_at_store))

  # Bring the items home.
  grocery_bags_at_home = return_from_store(cart_list)

  # Put the items away.
  pantry_list = []
  for item_at_home in grocery_bags_at_home:
    pantry_list.append(put_in_pantry(item_at_home))

  return pantry_list

(define shopping-trip2 grocery-list
  (let ([grocery-list-at-store (go-to-store grocery-list)])
    (put-in-pantry
      (return-from-store
        (pick-at-store grocery-list-at-store)))))

I am being sloppy here by assuming that the helper functions can accept (and will return) either a single item or a list of items

If we have \(n\) items in our list, how long does this procedure take?

• Go to the store just once.

• Return from the store just once.

• As \(n\) gets larger, total time will increasingly be determined by those parts of the procedure which depend on \(n\).

• For large \(n\), we can essentially ignore the stuff which grows more slowly (or not at all) with \(n\).

Handcraft

Handcraft

Metaphor for software development—ingenuity, function, simplicity, resource constraints. And sometimes things are not entirely correct.

Knitting

The language used to communicate patterns uses exactly the same fundamental constructs as Python!!!

Knitting patterns, in particular, are communicated using language very similar to Python, so our first experiences are going to exploit the metaphor.

Knitting: examples

Show \(40 \times 40\), but then transition into \(n \times n\)—“one difference between a knitting project and our problems we solve”

Quantifying the Task

1. If we describe one dimension of a square rag by \(n\), how much work is done by the knitter? ____________
2. If we have enough yarn for 36,000,000 stitches, what is the largest rag we could make? ____________
3. If each stitch takes a second, what is the largest rag we could make in one evening? ____________
4. If it takes an evening to make a \(40 \times 40\) rag, how long will it take to make an \(80 \times 80\) rag? ____________
5. If it takes time \(t\) to make an \(n\) by \(n\) rag, how long will it take to make a \(3n \times 3n\) rag? ____________

General idea: quantify the size of the problem (\(n\)) and consider the cost of our task as that size increases.

Draw the parabola in 4. Point out that quadratic is slower than exponential growth.

Quantifying the task…

If we are solving a problem / writing an algorithm for an input of arbitrary size, we can parameterize the running time of the solution by the size of the input.

We usually denote this input size using the variable \(n\).

• We need to specify what \(n\) represents (in this case the length of each side of the square).
• Sometimes we need multiple parameters to describe the size of the problem (such as \(n\) and \(m\)).
• We pay attention to only the degree of n (so if a scarf takes \(3n^2 + 12n\) time, we are only interested in the fact it is \(n^2\))

• In this example we choose to label \(n\) as the side-length in stitches, but other choices are possible.
• We don’t care so much about units, so we communicate using the largest order term
  • A scarf which is always \(3n \times n\) takes time \(3n^2\) to knit, we ignore the 3 when we’re talking about algorithms. It’s the squared part that really determines how waiting time increases as the problem size increases.
  • We say that the variable term “dominates”.

But why did we introduce a “parameter”? What happened to the rows and stitches? What does this have to do with a computer processing data?

We are seeking to understand the effort / efficiency / complexity of solving the problem / running the algorithm in a simple / elegant manner, where we have abstracted away the clutter of the details of the problem.

Simplicity is the ultimate sophistication. It takes a lot of hard work to make something simple, to truly understand the underlying challenges and come up with elegant solutions. […] It’s not just minimalism or the absence of clutter. It involves digging through the depth of complexity. To be truly simple, you have to go really deep. […] You have to understand the essence of a product in order to be able to get rid of the parts that are not essential.

— Steve Jobs

In this course we will be seeking simplicity and elegance not only in our algorithms, but also in how we analyze them. In particular, when looking at the complexity of an algorithm we will ignore the constants and dominated terms.

Our software should be considered to be a means of communicating with other humans who want to know how we have solved the problem. Humans are not good readers, but they think they are good programmers, so if they cannot understand our solution, then they will just rewrite it! (Complexity gives people a reason not to connect)

It would be nide to include this link, but I cannot figure out how to adjust the font size to make room. For further reading: https://www.smithsonianmag.com/arts-culture/how-steve-jobs-love-of-simplicity-fueled-a-design-revolution-23868877/

Analyzing Complexity

Handcraft and Code

Knitting model:

• Side length is \(n\)

• One stitch is a unit of work

• \(n\) rows, \(n\) stitches per row

• Total work is \(n^2\)

Walk through code. Yes, we are mutating variable cloth, and we generally discourage mutation. Are we mutating the string to which cloth refers?

Count work to arrive at \(n^2\) conclusion.

• Which line is executed most frequently?
• How many times is outer for loop executed?
• How many total times is line 5 (inner for loop) executed?

Quantifying the task…

Suppose we can knit 1 (= 10⁰) stitches per second….

The degree (in n) makes a very big difference!

time \ n	10	100	1000
log n	~3 s	~6½ s	~10 s
n	10 s	102 s ~ 1½ min	103 s ~ 16½ min
n log n	3(10) s ~ ½ min	6(102) s ~ 10 min	104 s ~ 2½ hours
n2	100 s ~ 1½ min	104 s ~ 2½ hours	106 s ~ 11½ days
n3	1000 s ~ 16½ min	106 s ~ 11½ days	109 s ~ 31½ years
2n	1024 s ~ 17 min	~1030 s	~10301 s

Notes: “log” is base 2, and the age of the universe: ~10¹⁸ s

Log factors are great! Linear (power 1) is good. Powers 2+ (polynomial) is okay as long as \(n\) is reasonably small. If \(n\) is in the exponent, forget about it…

Quantifying the task…

But computers are much faster. Suppose we can “knit” 10¹² stitches / s

time \ n	10	100	1000	106	1012
log n	~3(10-12) s	~6½(10-12) s	~10(10-12) s	~20(10-12) s	~40(10-12) s
n	10-11 s	10-10 s	10-9 s	10-6 s	1 s
n log n	3(10-11) s	6(10-10) s	10-8 s	~20(10-6) s	~40 s
n2	10-10 s	10-8 s	10-6 s	1 s	1012 s
n3	10-9 s	10-6 s	10-3 s	106 s	1024 s
2n	~10-9 s	~1018 s	~10289 s

Notes: proteins fold in ~10^-6 s and the age of the universe: ~10¹⁸ s

So the amount of computation we do inside our algorithm actually matters as our data increases.

A fast laptop might achieve 10¹² flops. Fastest supercomputer is 2198 x 10¹⁵ flops.

If our cloth/data size is 1000, and we need to compute \(n^3\) steps/stitches (like knitting a cube!!), then the total time is 1000³/10¹² == 10^-3 or one thousandth of a second. NBD

BUT let’s look at bigger data. 10¹² (~128gb … pretty big) 10¹² mm == 10⁶ km (for reference, 384,400 km to the moon or 149(10⁶) km to the sun. Knitting something that big would take 10¹² seconds or ~32000 years. The sun will long since have burnt out by 10¹⁸

Punchline – we don’t want to do \(2^n\) amount of computation, and we need creative approaches for big data.

Recap – we’ve seen a problem whose size we characterize by \(n^2\), we’ll see problems whose time we characterize by \(n\), for sure, and later in the term, we’ll see a problem which is very simply stated, whose size we characterize by \(2^n\). ☹