Week 6: Dictionaries

BSCS1001 — IIT Madras BS Degree Prerequisite: Week 5 (Lists) Cross-links: BSCS1002-Python (Week 8 — Dictionaries), BSCS2002-PDSA (Week 3 — Map ADT)

1. Motivation: Beyond Lists

Real-world analogy: A list is like a row of lockers numbered 0, 1, 2... You must walk down the row to find something. A dictionary is like a phonebook — you look up the name (key) and instantly get the number (value).

2. What is a Dictionary?

Syntax

pseudo
// Creating a dictionary
d = {}
// Adding key-value pairs
d["Rahul"] = 92
d["Ritika"] = 89
// Accessing values
marks = d["Rahul"]      // marks = 92

Visual Representation

Key Properties

Dictionary vs Record

3. Dictionary Operations

Core Operations

Assigning Values

pseudo
// First assignment — creates the entry
chemMarks["Rahul"] = 92
// Re-assignment — updates the value
chemMarks["Rahul"] = 95    // Now Rahul's mark is 95
// Incrementing a value
chemMarks["Rahul"] = chemMarks["Rahul"] + 5  // Now 100

Keys Must Be Unique

pseudo
d = {}
d["Alice"] = 85
d["Alice"] = 90    // Overwrites! Now d["Alice"] = 90

Common Gotcha: Key Doesn't Exist

python
Run Inline
d = {"Rahul": 92}
print(d["Ritika"])    // ERROR! "Ritika" is not a key

python
Run Inline
if (isKey(d, "Ritika")) {
    print(d["Ritika"])
}
else {
    print("Key not found")
}

4. Building Dictionaries

Pattern: Collect Data from Dataset

pseudo
d = {}
while (Table 1 has more rows) {
    Read the first row X in Table 1
    key = some field of X
    value = some other field of X
    d[key] = value
    Move X to Table 2
}

Example: Chemistry Marks Dictionary

pseudo
chemMarks = {}
while (Table 1 has more rows) {
    Read the first row X in Table 1
    name = X.Name
    marks = X.ChemistryMarks
    chemMarks[name] = marks
    Move X to Table 2
}

Example: Counting with Dictionaries

sql
// Count how many students from each city
cityCount = {}
while (Table 1 has more rows) {
    Read the first row X in Table 1
    city = X.City
    if (isKey(cityCount, city)) {
        cityCount[city] = cityCount[city] + 1
    }
    else {
        cityCount[city] = 1
    }
    Move X to Table 2
}

5. Processing Dictionaries

Iterating Through Keys

pseudo
foreach k in keys(d) {
    // Do something with d[k]
}

Example: Compute Average

pseudo
total = 0
count = 0
foreach k in keys(chemMarks) {
    total = total + chemMarks[k]
    count = count + 1
}
average = total / count

Example: Find Max Value

pseudo
maxMark = 0
topStudent = ""
foreach k in keys(chemMarks) {
    if (chemMarks[k] > maxMark) {
        maxMark = chemMarks[k]
        topStudent = k
    }
}

Example: Filter Students Above Threshold

pseudo
above80 = []
foreach k in keys(chemMarks) {
    if (chemMarks[k] > 80) {
        above80 = above80 ++ [k]
    }
}

6. isKey Operation

What isKey Does

How isKey Works (Conceptual)

pseudo
Procedure isKey(d, k)
    found = False
    foreach key in keys(d) {
        if (key == k) {
            found = True
            exitloop
        }
    }
    return(found)
End isKey

Important: In our course, we assume isKey is provided as a built-in operation that works in constant time (instant lookup), not by scanning all keys.

Typical Usage Pattern

pseudo
// Add to count if key exists, otherwise create
if (isKey(runs, "Kohli")) {
    runs["Kohli"] = runs["Kohli"] + score
}
else {
    runs["Kohli"] = score
}

7. Birthday Paradox with Dictionaries

Algorithm

pseudo
Procedure FindSharedBirthdays() {
    birthdays = {}
    duplicates = {}
    while (Table 1 has more rows) {
        Read the first row X in Table 1
        dob = X.Dob
        seqno = X.SeqNo
        if (isKey(birthdays, dob)) {
            // This birthday already seen — mark as duplicate
            duplicates[dob] = True
            // Store student under this birthday
            birthdays[dob][seqno] = True
        }
        else {
            // First time seeing this birthday
            birthdays[dob] = {}
            birthdays[dob][seqno] = True
        }
        Move X to Table 2
    }
    return(duplicates)
End FindSharedBirthdays

How It Works (with Nested Dictionary)

pseudo
birthdays = {
    45:  {101: True, 103: True},    // Two students born on day 45
    120: {102: True, 105: True},    // Two students born on day 120
    200: {104: True}                 // One student born on day 200
}

Tracing

Complexity: O(N) — Linear!

8. Dictionary Applications

Customer Spending Analysis

pseudo
// Build dictionary: customer → total spending
spending = {}
while (Table 1 has more rows) {
    Read the first row X in Table 1
    customer = X.CustomerName
    amount = X.Amount
    if (isKey(spending, customer)) {
        spending[customer] = spending[customer] + amount
    }
    else {
        spending[customer] = amount
    }
    Move X to Table 2
}

Pronoun Resolution

pseudo
partOfSpeech = {}
partOfSpeech["Noun"] = []
partOfSpeech["Pronoun"] = []
while (Table 1 has more rows) {
    Read the first row X in Table 1
    if (X.PartOfSpeech == "Noun") {
        partOfSpeech["Noun"] = partOfSpeech["Noun"] ++ [X.SerialNo]
    }
    if (X.PartOfSpeech == "Pronoun") {
        partOfSpeech["Pronoun"] = partOfSpeech["Pronoun"] ++ [X.SerialNo]
    }
    Move X to Table 2
}
// Now match each pronoun to nearest preceding noun
matchD = {}
foreach p in partOfSpeech["Pronoun"] {
    matched = -1
    foreach n in partOfSpeech["Noun"] {
        if (n < p) {
            matched = n
        }
        else {
            exitloop    // Nouns are sorted, no need to continue
        }
    }
    matchD[p] = matched
}

Food Items Analysis

pseudo
// Count food items per customer
foodD = {}
while (Table 1 has more rows) {
    Read the first row X in Table 1
    customer = X.CustomerName
    items = X.Items
    for each row in items {
        if (row.Category == "Food") {
            if (isKey(foodD, customer)) {
                foodD[customer] = foodD[customer] + 1
            }
            else {
                foodD[customer] = 1
            }
        }
    }
    Move X to Table 2
}

9. Comparison: List vs Dictionary

List vs Dictionary

When to Use What

Converting Between List and Dictionary

pseudo
// List of keys → dictionary with True values
students = ["Rahul", "Ritika", "Amit"]
studentDict = {}
foreach s in students {
    studentDict[s] = True
}
// Now: if (isKey(studentDict, "Rahul")) is instant

10. Practice Questions

Basic Questions

Show Answer

A dictionary stores key-value pairs. Each entry has a key (used to look up) and a value (the data stored). Keys must be unique. Q2. What does isKey(d, k) do? Show Answer

isKey(d, k) checks if k exists as a key in dictionary d. It returns True if the key exists, False otherwise. Q3. Write pseudocode to create a dictionary that stores students' ages (name → age). Show Answer

pseudo
ages = {}
ages["Alice"] = 20
ages["Bob"] = 22
ages["Charlie"] = 19

Show Answer

With nested iterations, finding shared birthdays requires O(N²) comparisons. With a dictionary, we can do it in O(N) — a single pass through the data. Dictionaries provide instant (O(1)) lookup by key, eliminating the need for pairwise comparisons.

Intermediate Questions

pseudo
d = {}
d["x"] = 10
d["y"] = 20
d["x"] = d["x"] + 5
d["z"] = d["x"] + d["y"]

Show Answer

Final: {"x": 15, "y": 20, "z": 35} Q6. Write pseudocode to find the student with the highest Chemistry mark using a dictionary. Show Answer

pseudo
chemMarks = {"Rahul": 92, "Ritika": 89, "Amit": 78, "Priya": 95}

maxMark = 0
topStudent = ""
foreach k in keys(chemMarks) {
    if (chemMarks[k] > maxMark) {
        maxMark = chemMarks[k]
        topStudent = k
    }
}
// topStudent = "Priya", maxMark = 95

Show Answer

• Record field: X.Name — the field name is fixed at design time. You must know the field name when writing the code.
• Dictionary key: d["Name"] — the key can be any value, including data read at runtime. You can use variables as keys.

Dictionaries are more flexible because keys can be computed dynamically. Q8. What happens if you access a key that doesn't exist in a dictionary? How do you avoid this? Show Answer

Accessing a non-existent key causes an error. To avoid this, always check with isKey first:

pseudo
if (isKey(d, someKey)) {
    value = d[someKey]    // Safe!
}
else {
    // Handle missing key
}

Advanced Questions

Show Answer

pseudo
Procedure DictIntersection(d1, d2) {
    result = {}
    foreach k in keys(d1) {
        if (isKey(d2, k)) {
            result[k] = d1[k]
        }
    }
    return(result)
End DictIntersection

// Example:
// d1 = {"a": 1, "b": 2, "c": 3}
// d2 = {"b": 20, "c": 30, "d": 40}
// Result: {"b": 2, "c": 3}

Show Answer

pseudo
wordCount = {}
while (Pile 1 has more cards) {
    Pick a card X
    word = X.Word

    if (isKey(wordCount, word)) {
        wordCount[word] = wordCount[word] + 1
    }
    else {
        wordCount[word] = 1
    }
}

// Find most frequent
maxCount = 0
mostFreq = ""
foreach w in keys(wordCount) {
    if (wordCount[w] > maxCount) {
        maxCount = wordCount[w]
        mostFreq = w
    }
}

Show Answer

Best: Dictionary approach. It's simple, requires only one pass through the data (O(N)), and doesn't need pre-defined bins or nested loops. The key insight is using the birthday as the key and checking for duplicates via isKey. Q12. Write pseudocode to create a dictionary where each key maps to a LIST of values (e.g., students per city). Show Answer

pseudo
cityStudents = {}
while (Table 1 has more rows) {
    Read the first row X in Table 1
    city = X.City
    student = X.Name

    if (isKey(cityStudents, city)) {
        // Append to existing list
        cityStudents[city] = cityStudents[city] ++ [student]
    }
    else {
        // Create new list
        cityStudents[city] = [student]
    }
    Move X to Table 2
}

// Result: {"Chennai": ["Rahul", "Priya"], "Mumbai": ["Amit"]}

📚 Cross-References

Next Topic: 12 — Dictionary Applications

Quiz Tip: Birthday paradox with dictionaries is a classic — understand it thoroughly! Join Discord PreviousInsertion SortNextDictionary Applications