CS106B Programming Abstractions

Welcome to CS106B!

cbl@stanford.edu — Tue, 22 Sep 2026 00:00:00 -0700

Due Monday, September 28 at 11:59 pm Pacific (PDT, UTC-07:00)

In this course, we express all date/times in Pacific time. Our Paperless submission system also displays/records due dates and submission times in Pacific time.
This assignment is to be completed individually. Working in pairs/groups is not permitted.

Welcome to CS106B! This assignment is designed to help you get your development environment set up and running so that you can compile, run, and debug programs. There isn’t any actual programming involved, and we hope that this doesn’t take you too much time to complete. Remember, you don’t need to understand what the code you’re being asked to run is actually doing just yet. Over the course of the quarter, each of the different parts of this program will be illuminated! This assignment must be completed individually.

About Assessments

cbl@stanford.edu — Sat, 03 Jan 2026 00:00:00 -0800

We know that you are working hard on completing your assignments and that this work forms the primary mechanism for learning and mastering concepts in CS106B. If, after completing an assignment, you have a solid and confident understanding of how and why your code works, you are on the right track toward a deep understanding of CS106B’s core concepts! Since assignments focus on specific topics throughout the course progression, it can be valuable to have additional summative opportunities to assess your learning and receive feedback on your progress.

All IG Problems

cbl@stanford.edu — Fri, 21 Nov 2025 00:00:00 -0800

Here is a list of all the IG problems we’ve worked on in IGs throughout the quarter! We hope this is helpful in studying for the final.

IG1: `sumDigits()`

Topics: strings, transition to C++
📦 Starter code

Implement the int sumDigits(string s) function from the code below:

/* The sumDigits function returns the sum of all the digits in s.
   The function ignores negative numbers and only sums the individual
   digits. For example, `sumDigits("ab1c3d56--21x")` should return `18` (which is `1 + 3 + 5 + 6 + 2 + 1`).
   An empty string should return `0`. 
   You are welcome to use functions from the `cctype` and `strlib.h` libraries.
*/
int sumDigits(string s) {
    // code here!
 
     
}

int main() {
    string s = getLine("Enter a string with numbers and characters and punctuation, etc.: ");
    int sum = sumDigits(s);
    cout << "The sum of the digits in the string: " << sum << endl;
    return 0;
}

Solution:

Midterm Review Advice 1

cbl@stanford.edu — Mon, 20 Oct 2025 00:00:00 -0700

This advice was written by Julie Zelenski for her CS106B/CS107 students preparing for a traditional timed exam. We hope you find the advice here to be helpful when preparing, even though we have some slightly different constraints on our diagnostic this quarter.

Philosophy

First, a quote from Will Shortz, the crossword puzzle editor of the New York Times:

A crossword puzzle is a battle between the puzzle maker and editor on one side and the solver on the other. But unlike most battles, both sides here have the same goal – for the solver to win. A perfect puzzle may put up lots of resistance. It may, in fact, seem impossible at first. Ideally, though, in the end the solver should triumph and think, Oh, how clever I am! – Will Shortz, How to solve

Midterm Review Advice 2

cbl@stanford.edu — Mon, 20 Oct 2025 00:00:00 -0700

This advice was written by Keith Schwarz for his CS106B students preparing for a traditional timed exam. We hope you find the advice here to be helpful when preparing, even though we have some slightly different constraints on our diagnostic this quarter. Keep in mind that we are providing you with a Qt Creator project, but that it isn’t going to be set up to compile and test your code. It is more for your familiarity and convenience.

CS106B Late Policy

cbl@stanford.edu — Sun, 21 Sep 2025 00:00:00 -0700

Late Assignment Policy

The assignment deadline policy this quarter has been designed to provide all students with built-in flexibility. Here will be the general policy:

Assignments deadlines will fall at the end of the day in the Pacific time zone, i.e. 11:59pm GMT-7.
Preventative pro tip: One way to avoid accidentally missing a deadline is to submit unfinished work as soon as it would earn some credit, and then re-submit as you improve upon it. Then if something happens like your laptop falls into Lake Lag an hour before the deadline (for this hypothetical, imagine Lake Lag has water), your assignment grade might be saved by a mostly correct solution that you had already submitted.

Assignments

cbl@stanford.edu — Mon, 01 Sep 2025 00:00:00 -0700

We have a great set of assignments planned to give you practice with the material presented in lecture and section. Programming is a skill best learned by doing and these assignments form an integral part of your experience in this course. These projects will be fun, challenging, illuminating, and rewarding. Your sincere efforts on the assignments will help you develop powerful skills and a deeper understanding of computational problem-solving.

Common questions about assignments

What programming environment and tools are used?

Programs are written in the C++ language and we use the Qt Creator IDE for editing, compiling, and debugging. Please visit the Qt Installation Guide for install instructions.

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

Practice Exam Solutions

Q1) C++ fundamentals

bool findFreeBlock(Grid<string>& seatGrid, int k, GridLocation& loc) {
    for (int r = 0; r < seatGrid.numRows(); r++) {
        int count = 0; // count of num consecutive empty seats in current row
        for (int c = 0; c < seatGrid.numCols(); c++) {
            if (seatGrid[r][c].empty()) {
                count++;
                if (count == k) {
                    loc = { r, c - k + 1 };
                    return true;
                }
            } else {
                count = 0;
            }
        }
    }
    return false;
}

Q2) ADTs

int reseatGroup(Grid<string>& seatGrid, Map<string, Set<GridLocation>>& reservationDB, string groupCode) {
    // Start by "unlocking" the seat assignments from existing reservation
    Set<GridLocation> oldSeats = reservationDB[groupCode];
    int k = oldSeats.size();
    for (GridLocation seat : oldSeats) {
        seatGrid[seat] = "";
    }

    GridLocation loc;
    if (findFreeBlock(seatGrid, k, loc)) {
        // Update reservationDB with new block of seats
        reservationDB[groupCode] = getSeatsForBlock(loc, k);
    }

    // mark seat assignments (will restore old or set new)
    for (GridLocation seat : reservationDB[groupCode]) {
        seatGrid[seat] = groupCode;
    }

    // Take a set difference between seatsNow and oldSeats.
    // Elements that are in both will be removed.
    Set<GridLocation> changedSeats = oldSeats.difference(reservationDB[groupCode]);
    return changedSeats.size();
}

Q3) Code study: ADTs and Big-O

a) O(N²)

📅 CS106B Course Schedule

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

This is a preview of our planned schedule. The schedule may change as we go, and we will reflect those changes here.

About CS106B Programming Abstractions

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

This site is for CS106B

ADT warmup

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

“How I got better at debugging” by Julia Evans

For this course, you will write many C++ programs. But writing the code is only the first step; you also need strong skills in testing and debugging to bring a program to successful completion. Knowing your way around the debugger is key. Our assignments will feature warmup exercises that are designed to give you guided practice with the skills and tools for effective testing and debugging.

At the ballot box

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

In 1887, French mathematician Joseph Bertrand pondered an idealized election conducted between two candidates, A and B. Each voter casts a ballot for a single candidate and adds it to a sealed box. When the polls close, the box is shaken to mix up the order and ballots are removed one by one and tallied. At the end of the tally, candidate A has more votes than B and wins the election. Bertrand’s question was: What is the likelihood that the winning candidate A is strictly ahead of candidate B throughout the entire tally?

Background on huffman coding

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

When I was an undergrad, my Mac had a whopping 10MB disk which had me feeling like the big cheese on campus. Today, the dinkiest of storage devices is measured in gigabytes, and my status as a superhero is very much in doubt. But even though capacity has enlarged at an astounding rate, the files we store (images, music, and the all-important funny cat videos) keep pace with that growth, so even our gargantuan disks are overflowing.

Backtracking Warmup

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

When you encounter a bug in a program, your first instinct is often to ask “Why isn’t my program doing what I want it to do?”

One of the best ways to find that answer is to instead start with a different question: “What is my program doing, and why is that different than what I intended?”

The debugger is a powerful tool for observing exactly what a program is doing. With clear information about what is happening when a program is executing, you can then tackle the next questions of how that outcome relates to what you’ve expressed in code and how to change the code to instead reflect your intentions.

Balanced Operators

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

In the syntax of most programming languages, there are characters that occur only in nested pairs, which are called bracketing operators. C++, for example, has these bracketing operators:

( . . . )
[ . . . ]
{ . . . }

In a well-formed program, the bracketing operators must be properly nested and matched. As part of analyzing your code, the compiler confirms all expressions are balanced. If you have ever failed to follow protocol, you have encountered the compiler’s ire expressed in a swath of red text and highlighting. For this assignment task, you will write your own code to detect when the bracketing operators in an expression are not balanced.

Beyond Algorithmic Analysis

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

In Week 2 of lecture, you learned about using the techniques of benchmarking (i.e., measuring run time in our test framework) and counting the number of writes to “boxes” of memory, to determine performance characteristics of different algorithms using a Vector. Next week, we will expand and formalize our accounting of the number of steps in an algorithm using a technique called Big-O analysis, which will inform our study of algorithms throughout the rest of the course. However, we want to approach the topic of efficiency and optimization with a certain amount of cautious skepticism in terms of its ethical implications. This assignment is designed to prepare you to learn about Big-O by pausing to consider these implications.

Common Build/Run/Debug Issues

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

This page contains a list of common issues students may encounter when trying to build, run, or debug their code. If you’re stuck on an issue, try searching this page using Ctrl+F (Command+F on Mac) to jump quickly to the text matching the error message or description of the issue you are having. You can also check out the [Qt troubleshooting guide][troubleshooting] if you’re having issues with Qt Creator. {: .alert .alert-success}

Course placement

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

The CS department offers many programming courses and it can be difficult to know exactly where to begin. This handout provides a general overview of these classes and some advice about selecting the class that’s right for you.

If you have any questions, please feel free to come talk to the course staff! We’d be happy to offer one-on-one advice.

CS106A: Start here!

CS106A is our first-quarter programming course. It teaches the widely-used Python programming language along with good software engineering principles. If you’re interested in learning how to program a computer, this is the place to start. CS106A has no prerequisites – it’s open to everyone! The course is explicitly designed to appeal to humanists and social scientists as well as hard-core techies. In fact, most CS 106A graduates end up majoring outside of the School of Engineering. The course requires no previous background in programming, but does require considerable dedication and hard work.

CS106B and the Honor Code

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

Since 1921, academic conduct for students at Stanford has been governed by the Honor Code, which reads as follows (with updates in 2023):

THE STANFORD UNIVERSITY HONOR CODE

The Honor Code is an undertaking of the Stanford academic community, individually and collectively. Its purpose is to uphold a culture of academic honesty.

Students will support this culture of academic honesty by neither giving nor accepting unpermitted academic aid in any work that serves as a component of grading or evaluation, including assignments, examinations, and research.

Debugging warmup

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

“If you understand a bug, you can fix it!” by Julia Evans

This exercise will add a few new debugger tricks to your repertoire that will come in handy for this assignment and into the future.

Debugging objects

The files ball.h and ball.cpp define a Ball class that models a ball bouncing in a window. The member variables for a ball include its x and y position, its velocity on both axes, and the window where the ball is drawn.

Doubly-Linked List Warmup

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

Part Two: Doubly-Linked List Warmup

A common variant on the traditional linked list is the doubly-linked list. Unlike a traditional linked list, in a doubly-linked list each cell contains a pointer both to the cell that comes after it in the sequence and a pointer to the cell that comes before it in the sequence. This is shown here:

struct Cell {
    string value; // Or whatever type of data you'd like, really
    Cell*  next;  // Pointer to the next cell in the list
    Cell*  prev;  // Pointer to the previous cell in the list
};

Here’s how we might draw a doubly-linked list:

Ethics of Prioritization and Ranking

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

Design analysis

You’re working as a software engineer and have been contracted to build a priority queue for a client. The client’s specification requests that the design support exactly three levels of priority: “high”, “medium”, and “low”. Elements enqueued at the same priority level are to be processed in FIFO (first-in-first-out) order. Your manager proposes a design for a new PQueue class whose internal implementation consists of three ordinary Queues: one for high priority elements, one for medium priority elements, and one for low priority elements. To dequeue elements, it would first drain the high priority queue, then medium and low.

Getting Help

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

We provide a variety of support resources in CS106B to help you as much as possible with assignment, material, or other questions throughout the quarter.

The main resource for conceptual and debugging help with your assignments will be the LaIR, which is the help center staffed by section leaders. The lecturers and Head TA will hold regular office hours. You can ask questions and receive help asynchronously using the Ed Discussion forum.

To help you make the most of these resources, we’ve compiled a list of the kinds of common issues or questions that may come up throughout the quarter, and the best way to get help for each.

Huffman coding

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

Huffman coding is an algorithm devised by David Huffman in 1952 for compressing data. This simple and elegant approach is powerful enough that variants of it are still used today in computer networks, fax machines, modems, HDTV, and other areas. You will be impressed with its clever use of trees and your ability to implement such a nifty tool!

Huffman warmup

Be sure to have completed the preparatory warmup exercises.

Review starter code

Before you get started in earnest, take stock of the files in the starter project and what’s provided to you. Here are some details to become acquainted with:

Huffman tree warmup

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

“Debugging is hard, take breaks!” by Julia Evans

In these exercises, you will practice with Huffman trees to establish a solid understanding of the Huffman algorithm before you start implementing the program.

Huffman coding was introduced in Lecture 24. We also posted a handout] that repeats that info if reading works better for you than lecture. Be sure you have watched/read this content first! The assignment writeup assumes familiarity with this content and does not repeat it. {:.alert .alert-warning}

IG1: CS106B

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

The first IG!

📦 Starter code
For this IG, please (roughly) follow the following script:

Introduce yourself, and ask the student how the course is going so far, and ask if there is anything they are excited about or concerned about. Since this is the first IG, it’s a great time to get to know your students more.
Ask if they have any questions about assignment 1. How did it go? Were there any challenging parts? Feel free to discuss concerns you may have about the assignment.
Once that discussion is finished (a few minutes, perhaps), say that you’d like to go over another problem that has a similar feel to assignment 1. Specifically, we want to write the int sumDigits(string s) function from the code you can see down at the bottom of the page:
You can code it together on a white board, on paper, or on your computer (see the Qt project above). If you code it in Qt, there are PROVIDED_TEST functions you can use to test the code.
Try to let the student do the bulk of the coding. If they get stuck, help them as you might in the LaIR.
If they are successful, congratulate them, and tell them that it looks like they are making great progress in the course. If they struggled or didn’t finish the problem, talk to them about going back over assignment 1, and perhaps reviewing the section code from last week.
After IG, fill out a quick check-plus / check / check-minus bucket in the IG Problem category of A1’s Paperless assignment (note: this category is hidden to students). We aren’t using those marks to assess the student, but to keep an eye on students that may be struggling. Don’t worry, the points are just there to allow for bucket grading – this does not contribute to the student’s grade
- check-plus: the student did a great job! They were able to solve the problem independently or with very very minimal interaction with you. They seem confident on this week’s material and seem caught up with lecture.
- check: the student was able to solve most of the problem, but required some prompting from you. There was a lack of understanding in a few areas of the problem. There is room for improvement, but the student seems to have some concepts down.
- check-minus: the student made little to no progress on the problem, and required much interaction with you in order to write any code. There was a serious lack of understanding of fundamental concepts from lecture this week.

Enjoy! Please reach out to Cynthia or Yasmine if you have any questions or feedback. Scroll down to see the problem!

IG3: Recursion

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

IG problem for the week of 2/2 (Week 5)

📦 Starter code

Happy Week 5! We hope your week is off to a great start and that IGs went well for A2 last week. Here is all the information you need for IGs during Week 5 (for A3).

IG6: Linked Lists

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

IG problem for the week of 11/16/2025 (Week 9)

📦 Starter code

Happy Week 9, everybody! We hope you’re doing well. Here is the information you need for this week’s IG problem.

LaIR helper hours

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

What are LaIR helper hours?

LaIR helper hours are an additional set of office hours staffed by our awesome fleet of section leaders. At the LaIR, students can get individual help with debugging and conceptual questions.

For more information on Black LaIR, run by Stanford Black in CS, see their website.

Logistics

LaIR starts week 2 of the quarter.
The LaIR help queue is open Sunday-Thursday this quarter. To sign up for help, add your request to the queue using the LaIR signup page.
In-person LaIR is in CoDa B60.

Weekly schedule

LaIR runs Sunday-Thursday, 7-11PM Pacific Time

Lectures

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

We have scheduled our lecture to meet in the largest room available on campus, and expect all on campus students to attend in person and engage with the learning activities. Although there is a policy in place to allow for some flexibility (see syllabus), I want to emphasize how important it is to attend in person if at all possible. By watching videos, you get access to what I’ve said in class, but you are robbed of the experience of hearing what your seatmates have to say during the problem-solving activities, as well as of the opportunity to say things to them. This practice in real-time verbal grappling with programming concepts is essential training for anyone planning a career that involves software engineering or working with software engineers.

Mazes

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

A maze is a twisty and convoluted arrangement of corridors that challenges the solver to find a path from the entry to the exit. This part of the assignment is about using ADTs to represent, process, and solve mazes.

An introduction to mazes

Labyrinths and mazes have fascinated humans since ancient times (remember Theseus and the Minotaur?), but mazes can be more than just recreation. The mathematician Leonhard Euler was one of the first to analyze mazes mathematically, and in doing so, he founded the branch of mathematics known as topology. Many algorithms that operate on mazes are closely related to graph theory and have applications to diverse tasks such as designing circuit boards, routing network traffic, motion planning, and social networking.

Merge

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

Binary merge

The binary merge operation is a very common operation in computer science, where two individual sorted sequences are merged into one larger sorted sequence. Merging is the backbone of many different sorting tasks (some of which we will explore later in the course), making this operation useful in a broad array of applications.

Implementing merge

Your first task is to write the function

Queue<int> binaryMerge(Queue<int> one, Queue<int> two)

which performs an iterative binary merge. Here are the specifications:

Office Hours

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

Overview

The LaIR helper hours are held each night Sunday through Thursday, and staffed by our sturdy fleet of section leaders. At the LaIR, students can get individual help with debugging and conceptual questions.

The instructor and Head TA will also be holding weekly office hours throughout the quarter for you to discuss any questions you might have about assignments, course material or simply Computer Science and life in general. The schedule is on the course home page in the left sidebar.

Part 1: Debugging Warmup

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

This exercise will add a few new debugger tricks to your repertoire that will come in handy for this assignment and into the future.

Debugging Objects

This warmup exercise uses a bouncing ball simulation. The files Ball.h and Ball.cpp define a Ball class that models a ball bouncing in a window. The member variables for a ball include its x and y positions, its velocity on both axes, and the bounding box in which it bounces.

Part 2: Simulate a String Instrument

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

Your first step in building the Tone Matrix is to implement a StringInstrument type that performs a simplified physical simulation of a plucked string instrument. We’ll begin with a quick overview of how computers handle sound, then discuss what you need to do.

Overview: Sound Waves and Digital Sound

Sound is a type of wave that moves through the air. The characteristics of those waves determine what you hear. A full description of sound perception is beyond the scope of this course, so for the purposes of this assignment we’ll focus on three attributes of sound waves. Those attributes are the amplitude of the wave (how intensely the wave oscillates between high and low), the frequency of the wave (how many times the wave changes from high to low in one second), and the shape of the wave (the pattern by which the wave switches from high to low).

Part 3: Implement the Tone Matrix

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

You now have a working string instrument simulation. Your next task is to implement the ToneMatrix type, which will maintain a grid of lights, respond to user input, determine when to pluck each string, and decide what data gets sent to the computer speakers.

Here’s how ToneMatrix is defined:

class ToneMatrix {
public:
    /* Creates a Tone Matrix whose grid is gridSize x gridSize and
     * where each light in the matrix has size lightSize x lightSize.
     * The lightSize parameter just determines the size, in pixels,
     * of each light in the grid.
     */
    ToneMatrix(int gridSize, int lightSize);
    
    /* Frees all memory used by this Tone Matrix. */
    ~ToneMatrix();

    /* Reacts to the mouse being pressed at a given position on
     * the screen, toggling the state of the light the mouse
     * hovers over.
     */
    void mousePressed(int mouseX, int mouseY);
    
    /* Reacts to the mouse being dragged from its previous
     * position to position (mouseX, mouseY). The light at the
     * new position has its state updated appropriately. Details
     * are given later.
     */
    void mouseDragged(int mouseX, int mouseY);

    /* Draws each light in the Tone Matrix. Details are
     * given later.
     */
    void draw() const;

    /* Advances time forward one step, returning the next sound
     * sample to play. Details are given later.
     */
    Sample nextSample();
    
    /* Described later. */
    void resize(int newGridSize);

private:
    /* Number of lights in one side of the grid (e.g. in a 16 x 16
     * grid, this will be 16).
     */
    int _gridSize;

    /* How big each light in the tone matrix is. */
    int _lightSize;
    
    /* The 2D grid of lights in the matrix; details are given below. */
    bool* _grid;
    
    /* The instruments corresponding to each row. */
    StringInstrument* _instruments;
    
    /* Additional data members and member functions of your own choosing;
     * you're free to add extra information here if you'd like. Details are
     * given below. Friendly reminder to follow the convention of adding an
     * underscore in front of any private member variables you declare!
     */
};

We’ve broken the task of implementing this type down into four smaller milestones to be completed in sequence.

Particle System

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

Part Three: Particle Systems

Many computer-generated visual effects - whether in blockbuster Hollywood movies or in video games - make use of particle systems. As the name suggests, a particle system is a system that consists of individual units called particles. Those particles can have attributes like position, color, velocity, etc., and by maintaining systems consisting of hundreds or thousands of particles it’s possible to build some beautiful effects from simple pieces.

Perfect Numbers

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

This warmup task gives you practice with C++ expressions, control structures, and functions, as well as testing and debugging your code.

Throughout the writeup, we pose thought questions (in the highlighted yellow boxes) for you to answer. The starter project includes the file short_answer.txt (located under “Other Files” in the Qt Project pane). Edit this file to fill in your responses and submit it with your code. Your section leader will review your responses as part of grading. We’ll be evaluating the sincerity and thoughtfulness of your reflection and reasoning; not a rigid “right/wrong” thing.

PQ Array

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

What is a Priority Queue?

A standard queue processes elements in the first-in, first-out (“FIFO”) manner typical of ordinary waiting lines. New elements are added to the back of the queue and the next element to be processed is taken from the front. Queues are a very useful abstraction, but a FIFO strategy isn’t always what is needed.

A hospital emergency room, for example, needs to schedule patients according to priority. A patient with a more critical problem will pre-empt others who arrived earlier. The data structure that supports this behavior is called a priority queue. Each element is enqueued with an associated priority, and dequeue retrieves the element with the most urgent priority. There are many practical applications for a priority queue, both inside and outside computer science!

PQ client

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

Put your client hat on!

Having finished PQArray and before starting on PQHeap, we take a brief diversion to appreciate the utility of the Priority Queue class as an abstraction for solving interesting and challenging problems.

While acting in the role of class implementer, the programmer is head down, focusing on the nitty-gritty of the functionality, navigating the challenges and tricky details to ensure the class works correctly in all situations. You just experienced this for yourself for PQArray. However, once the class is tested and debugged, it is a delight to switch hats to become a client of your own data structure and take advantage of what the class has to offer! Remember in previous assignments when you made use of Vector and Map to solve problems without worrying about how those data structures were actually implemented? Let’s revisit this powerful land of problem-solving and see what you can do with a working implementation of a handy data structure like the PQArray now in your repertoire.

PQ Heap

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

ADTs for the win

Now you are ready for the pièce de résistance — implementing the priority queue as a binary heap. One of the fantastic features of C++ classes as an abstraction is that you can swap out its inner workings for a totally different implementation, with minimal impact on the client. For example, you can change how your internal algorithms to rev up performance or switch a more compact data representation to save space, all the while your clients continue using the same interface, and receive the benefits of your improvements without lifting a finger.

Python to C++ Guide

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

Denoting Structure: Semicolons, Parentheses, and Braces

In Python, indentation and whitespace indicates where statements end and how structures nest inside one another. In C++, you need to explicitly indicate this using semicolons, parentheses, and braces.

Curly braces – the { and } characters – are almost exactly equivalent to Python indentation. You’ll need to use them in if statements, for loops, while loops, and functions. For example:

Questions from prospective students

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

How will lectures be delivered? Is attendance required? Will they be recorded?

Lectures will be delivered live MWF 1:30pm in Hewlett 200 auditorium. Attendance is required for on-campus students. Read more about lectures.

How will sections work? Is attendance required?

Sections will meet weekly in person (except for CGOE sections) and your attendance and participation in section is required and contributes 10% of your course grade. Note the section times listed in Axess are not accurate. Section times will be arranged in the first week of the quarter. Read more about section.

Recursion warmup

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

“Bugs are normal” by Julia Evans

1) Examine recursive stack frames (`factorial`)

The factorial n! is defined as the product n * (n-1) * (n-2) * ... * 3 * 2 * 1. The recursive approach to computing factorials uses the insight that:

0! is defined to be 1
n! can be computed as n * (n-1)!

To express this in code, we write a base case to return 1 for zero and use a recursive case to compute the result for n building on the result from n-1.

Search Engine

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

An introduction to search engines

Search engines are one of the most influential developments of the modern internet age and have completely revolutionized how users interact with the web. What was once an intractable jumble of data with no semblance of organization has become a treasure trove of useful information due to the magic of search. Armed with the power of Map and Set, you can recreate this phenomenal achievement yourself. Once completed, you will understand the core technology underpinning Spotlight, Google, and Bing, and have solid practice in the use of the Map and Set ADTs.

Section

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

Each week, you’ll meet for an hour in a small group discussion section. The discussion section will be led by your assigned section leader, who is also your mentor and grader in the course. During section, you and your peers will review the material that has been introduced in lecture, work together on the section practice problems, and ask and answer questions.

The section materials for each week consist of a set of problems for further practice with the recent lecture topics. You’re not expected to complete these problems before attending section nor are they submitted to be graded.

Sierpinski

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

Recursion can produce incredible and beautiful images that have self-similar subparts. The designs are known as fractals. One of the most famous fractals is the Sierpinski triangle, named after the Polish mathematician Waclaw Sierpinski (1882–1969).

As with many self-similar patterns, it is defined recursively:

An order-0 Sierpinski triangle is a single filled triangle.
An order*-n* Sierpinski triangle, where n > 0, consists of three Sierpinski triangles of order n – 1, whose side lengths are half the size of the original side lengths, arranged so that they meet corner-to-corner.

For example, here are Sierpinski triangles of the first few orders:

Soundex

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

For the Soundex search portion of the assignment you will:

study a real-world algorithm used by the U.S. Census to encode the phonetic pronunciation of surnames.
implement the algorithm, developing a function that can take surnames as input and produce phonetic encodings as output.
implement a console program that allows users to input a surname and then find all matches in a database of Stanford surnames that have the same encoding.
respond to a few reflective questions on the efficacy and limitations of this algorithm.

The coding is mostly C++ string processing, along with a little bit of file reading and use of Vector. You’ll also be practicing with use of decomposition and a test-as-you-go strategy. The two files you will be editing are soundex.cpp (for the code) and short_answer.txt (for responses to thought questions).

Style Guide

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

You may think the motivation for good style is earning that ✔+ from your section leader, but the most important beneficiary of your efforts is you yourself. Committing yourself to writing tidy, well-structured code from the start sets you up for good times to come. Your code will be easier to test, will have fewer bugs, and what bugs there are will be more isolated and easier to track down. You finish faster, your results are better, and your life is more pleasant. What’s not to like?

Submit checklist

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

This handy checklist is designed to help confirm your code is fully ready to go before you submit it. Before you send it in for grading, take a few minutes to work through this checklist.

Functionality

✅ I’ve re-read the assignment writeup and verified my program matches the required specification.
✅ I’ve reviewed my code and understand each line of code I’ve written, why it’s there, and why it’s necessary.

Syllabus

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

Hi there 👋 and welcome to CS106B!

CS106B Programming Abstractions is the second course in our introductory programming sequence. The prerequisite CS106A establishes a solid foundation in programming methodology and problem-solving in Python. With that under your belt, CS106B will acquaint you with the C++ programming language and introduce advanced programming techniques such as recursion, algorithm analysis, data abstraction, explore classic data structures and algorithms, and give you practice applying these tools to solving complex problems.

Testing and the SimpleTest framework

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

Why testing?

Anybody that writes code for some purpose (whether as a researcher, a software engineer, or in any other profession) will get to the point where others are relying on their code. Bugs in software can be dangerous or even deadly. Additionally, users do not enjoy using software that is buggy and crashes and fixing bugs once the software is in production is very costly. Most importantly, good engineers take pride in building things that work well and are robust.

Textbook

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

{: style=“float:right;”}

The CS106B textbook is Roberts, Eric S. Programming Abstractions in C++ , ISBN 978-0133454840.

The book was written by Stanford CS professor Eric Roberts and targeted directly for this course. Readings from the textbook are suggested to accompany lecture.

Section problems and programming homework will not be assigned directly out of the textbook and it possible to succeed in the course without it. However, we think you will appreciate it as a supplement to the presentation of the material in lecture and section. It also contains a wealth of practice problems for self-study.

The Labyrinth!

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

You have been trapped in a labyrinth, and your only hope to escape is to cast the magic spell that will free you from its walls. To do so, you will need to explore the labyrinth to find three magical items:

The Spellbook (📕), which contains the spell you need to cast to escape.
The Potion (⚗), containing the arcane compounds that power the spell.
The Wand (⚚), which concentrates your focus to make the spell work.

Once you have all three items, you can cast the spell to escape to safety.

Tile Matching - The Pattern Puzzle Solver

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

Image source: Rob's Puzzle Page

Edge-matching Puzzles

In this part of the assignment, you will explore using backtracking recursion to solve an edge-matching puzzle. Edge-matching puzzles have been around since the late 1800s; the vintage puzzle for Vess Cola shown above was a common advertising giveaway during the 1930s-1950s. For the puzzle, you are given a set of square tiles that have patterned edges and the goal is to place all tiles into a grid, having located and rotated all tiles in such a way that all edges “match”. In the Vess puzzle, the edge containing a bottle top in a particular color triangle “matches” the edge containing a bottle bottom in the same color triangle. As an example, consider the middle tile of the puzzle, which correctly matches on all edges. Its north edge (cream bottle bottom) matches the south edge (cream bottle top) of the adjacent tile above. Its east edge (red bottle top) matches the west edge (red bottle bottom) of the adjacent tile to the right, and so on for its south and west edges. On the other hand, the corner tile in the upper left does not match on its east edge nor on its south edge.

Voting Power

cbl@stanford.edu — Mon, 01 Jan 0001 00:00:00 +0000

Attribution: This assignment was designed by Julie Zelenski

🖐🏿🖐🏼 Be counted!🖐🏻🖐🏽

Stanford Votes

“It’s not the voting that’s democracy; it’s the counting.” – Tom Stoppard, Jumpers

Block voting systems

It’s said that “every vote counts,” but does every vote count equally? A block voting system such as the U.S. Electoral College makes for an interesting case study in analyzing the relative voting power of each block in a system where blocks have different weights.

CS106B Programming Abstractions

Welcome to CS106B!

About Assessments

All IG Problems

IG1: sumDigits()

Midterm Review Advice 1

Philosophy

Midterm Review Advice 2

CS106B Late Policy

Late Assignment Policy

Assignments

Common questions about assignments

What programming environment and tools are used?

Practice Exam Solutions

Q1) C++ fundamentals

Q2) ADTs

Q3) Code study: ADTs and Big-O

📅 CS106B Course Schedule

About CS106B Programming Abstractions

ADT warmup

At the ballot box

Background on huffman coding

Backtracking Warmup

Balanced Operators

Beyond Algorithmic Analysis

Common Build/Run/Debug Issues

Course placement

CS106A: Start here!

CS106B and the Honor Code

Debugging warmup

Debugging objects

Doubly-Linked List Warmup

Part Two: Doubly-Linked List Warmup

Ethics of Prioritization and Ranking

Design analysis

Getting Help

Huffman coding

Huffman warmup

Review starter code

Huffman tree warmup

IG1: CS106B

The first IG!

IG3: Recursion

IG problem for the week of 2/2 (Week 5)

IG6: Linked Lists

IG problem for the week of 11/16/2025 (Week 9)

LaIR helper hours

What are LaIR helper hours?

Logistics

Weekly schedule

Lectures

Mazes

An introduction to mazes

Merge

Binary merge

Implementing merge

Office Hours

Overview

Part 1: Debugging Warmup

Debugging Objects

Part 2: Simulate a String Instrument

Overview: Sound Waves and Digital Sound

Part 3: Implement the Tone Matrix

Particle System

Part Three: Particle Systems

Perfect Numbers

PQ Array

What is a Priority Queue?

PQ client

Put your client hat on!

PQ Heap

ADTs for the win

Python to C++ Guide

Denoting Structure: Semicolons, Parentheses, and Braces

Questions from prospective students

How will lectures be delivered? Is attendance required? Will they be recorded?

How will sections work? Is attendance required?

Recursion warmup

1) Examine recursive stack frames (factorial)

Search Engine

IG1: `sumDigits()`

1) Examine recursive stack frames (`factorial`)