What Makes an Algorithm Good?

Week 1, Monday

January 5, 2026

Welcome to DSCI 221

Where to Start?

Canvas: canvas.ubc.ca/courses/182082

Course Website: ubc-cs.github.io/dsci221

Piazza: piazza.com/ubc.ca/winterterm22025/dsci221

Term Structure

Week	Sunday	M	T	W	Lab	HW/PA	Examlet
1	1/4/2026	🎉	📺	🎉
2	1/11/2026	🎉	📺	🎉	🪄
3	1/18/2026	🎉	📺	🎉	🪄	HW1
4	1/25/2026	🎉	📺	🎉	🪄		🤩
5	2/1/2026	🎉	📺	🎉	🪄	PA1
6	2/8/2026	🎉	📺	🎉	🪄	HW2	🤩
7	2/15/2026
8	2/22/2026	🎉	📺	🎉	🪄
9	3/1/2026	🎉	📺	🎉	🪄	PA2	🤩
10	3/8/2026	🎉	📺	🎉	🪄
11	3/15/2026	🎉	📺	🎉	🪄		🤩
12	3/22/2026	🎉	📺	🎉	🪄	PA3
13	3/29/2026	🎉	📺	🎉	🪄		🤩
14	4/5/2026		📺	🎉		HW3

Where’s Scott?

Taylor Swift’s Eras Tour, Nashville, TN

“How would you find Scott in this crowd?”

Students will say: scan from front, shout his name, call his phone…

Guide toward: some methods check everyone (slow), some go direct (fast).

Which closet?

“Which closet?” / “What’s the tradeoff?”

Students will get: messy = fast to put away, slow to find. Tidy = opposite.

Key insight: you can’t optimize everything at once.

What’s this course about?

Pause. Let them guess. They’ll say “data structures”, “algorithms”, “efficiency”…

Then: “Let’s look at the goals.”

Course Goals

• Become familiar with fundamental data structures and algorithms
  • Learn when to use them
• Improve your ability to solve problems abstractly
  • Data structures and algorithms are the building blocks
• Improve your ability to analyze algorithms
  • Prove correctness
  • Gauge, compare, and improve time and space complexity
• Develop Python fluency for implementing solutions

“Which of these is different from your other courses?”

They’ll identify “analyze algorithms.” “What does ‘analyze’ mean?”

Algorithm Analysis

What does it mean to analyze an algorithm?

Let them generate ideas. They’ll say: “see if it works”, “how fast”, “how much memory”…

Then reveal: correctness, time complexity, space complexity.

“This is THE frame for the entire course.”

Correctness

• What does it mean for an algorithm to be correct?

 

• If an algorithm is not correct, is its value 0?

Discussion. Then ask:

Let them debate. Plant seeds: - Approximation (close enough) - Heuristics (usually right) - Probabilistic (correct with high probability)

“We’ll learn to prove correctness in Week 2.”

SEED PLANTED for Week 5 (hash tables) and Week 12 (NP-hardness).

Efficiency

Once we know it’s correct…

• How long does it take?
• How much memory does it use?

“This week: efficiency. Next week: proving correctness.”

Notice that these two things are related – if you use a lot of memory, you WILL spend a long time writing to that memory!

Shazam! demo

• 3 seconds of audio

• 100 million songs

• less than 1 second

“How is this possible?”

Shazam!

• Shazam’s database: ~100 million songs
• Your sample: 3 seconds of noisy audio
• Checking one song: ~0.001 seconds

How long to check all songs?

Let them calculate: 100,000,000 × 0.001 = 100,000 seconds ≈ 27.8 hours

“But Shazam answers in under a second. Something clever is happening.”

An Algorithmic Approach

0	1	2	3	4	5	6	7	…	99,999,999
🎵	🎵	🎵	🎵	🎵	🎵	🎵	🎵	…	🎵

• Is this correct?

• How long does it take to run?

“Is this correct?” (Yes)

“Is this efficient?” (Let’s see…)

“How long does it take?”

What factors might determine the running time?

Work with your neighbor: What factors affect how long find_song_naive takes?

They’ll say: “It depends!”

“What does it depend on?”

Let them generate: size of database, where the song is, machine speed…

Guide to: we care about SIZE. That’s the input to our algorithm.

Discussion results…

Machine speed

A faster computer runs the same code faster.

But that’s not about the algorithm.

Location of song

At the front? Quick!

At the end? Slow.

Not there at all? Slowest.

Size of database

100 songs vs 100 million songs

This is the big one.

We want to characterize the algorithm, not the machine or our luck.

“Which should we focus on for algorithm analysis?”

Machine speed varies (not about the algorithm). Location varies (best case vs worst case). Size is the INPUT.

“We parameterize by n.”

write T(n) running time on input of size n.  T(n) is a function!

The Scale Issue

Suppose our code requires ~0.001 second per song.

n = 100

100 × 0.001 = 0.1 sec

n = 100,000,000

100M × 0.001 = 27.8 hours

“Same algorithm. Same code. Wildly different outcomes.”

How does Shazam actually work?

“Hash table lookup doesn’t depend on the size of the database.”

O(1) — constant time.

“We’ll learn how in Week 5.”

Constant vs. Linear

Database size	Linear search	Hash lookup
1,000	1 sec	0.001 sec
1,000,000	1000 sec	0.001 sec
100,000,000	27 hours	0.001 sec

“The right data structure changes everything.”

Speed matters in surprising places

It’s not just Shazam!

YouTube

800 million videos

Every search: < 0.5 sec

Linear search would take hours

Genomics

Human genome: 3 billion base pairs

Finding a gene sequence

Naive: days → Real tools: seconds

Pandemic response

330 million people

Contact tracing within 2 connections

Relationships grow exponentially

As data grows, bad algorithms become impossible.

This Course

Data structures are clever ways to organize data so that algorithms can access it quickly.

“The right data structure can turn an impossible problem into a trivial one.”

Tie together: must be CORRECT and EFFICIENT.

What’s Next

This Week

Day	Topic
Tuesday	Counting steps, discovering patterns
Wednesday	The hierarchy: O(1) to O(2ⁿ)

Questions?