Week 6: Dictionary Applications

BSCS1001 — IIT Madras BS Degree Prerequisite: Topic 11 (Dictionaries) Cross-links: BSCS1002-Python (Week 8 — Dictionaries)

1. Motivation: Real-World Dictionary Problems

Problems That Benefit from Dictionaries

Key Insight: If you find yourself writing nested loops to find matches, ask: "Could I use a dictionary instead?"

2. Birthday Paradox with Dictionaries Revisited

The Problem

Dictionary Solution

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)) {
            duplicates[dob] = True
            birthdays[dob][seqno] = True
        }
        else {
            birthdays[dob] = {}
            birthdays[dob][seqno] = True
        }
        Move X to Table 2
    }
    return(duplicates)
End FindSharedBirthdays

Comparison of Approaches

3. Pronoun Resolution

Problem

// Step 1: Collect nouns and pronouns with their positions
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
}
// Step 2: 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
}

4. Customer Spending Analysis

Problem

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
}
// Find top spender
maxSpend = 0
topCustomer = ""
foreach c in keys(spending) {
    if (spending[c] > maxSpend) {
        maxSpend = spending[c]
        topCustomer = c
    }
}

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
}

5. Finding Common Elements Across Dictionaries

Intersection of Two Dictionaries

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

Comparing Train Routes

pseudo
// Represent routes as dictionaries for O(1) lookup
route1Dict = {}
foreach s in route1 {
    route1Dict[s] = True
}
common = []
foreach s in route2 {
    if (isKey(route1Dict, s)) {
        common = common ++ [s]
    }
}

6. Dictionary with Lists as Values

Students per City

pseudo
cityStudents = {}
while (Table 1 has more rows) {
    Read the first row X
    city = X.City
    if (isKey(cityStudents, city)) {
        cityStudents[city] = cityStudents[city] ++ [X.Name]
    }
    else {
        cityStudents[city] = [X.Name]
    }
    Move X
}
// Result: {"Chennai": ["Alice", "Charlie"], "Mumbai": ["Bob"]}

Mentors per Student (from Week 7)

pseudo
mentors = {}
foreach j in students {
    mentors[j] = {}
    foreach i in students {
        if (canMentor(i, j)) {
            mentors[j][i] = True
        }
    }
}
// mentors[j] is a dictionary of student j's mentors
// Length of keys gives mentor count

7. Side Effects with Dictionaries

Deleting a Key: With vs Without Side Effects

sql
Procedure DeleteKey(d, k) {
    foreach key in keys(d) {
        if (k == key) {
            remove key from d
        }
    }
}

pseudo
Procedure DeleteKey2(d, k) {
    myd = {}
    foreach key in keys(d) {
        if (k ≠ key) {
            myd[key] = d[key]
        }
    }
    return(myd)
End DeleteKey2
// Caller must reassign:
myd = DeleteKey2(myd, k)

Why Avoid Side Effects with Dictionaries?

1. Lose data (keys unexpectedly removed)
2. Get wrong results (values changed)
3. Encounter race conditions (concurrent access) Best practice: Unless the modification IS the goal (e.g., addStudent), return a new dictionary.

8. Practice Questions

Basic Questions

Show Answer

Dictionaries provide O(1) lookup per key, reducing the algorithm from O(N²) to O(N). A single pass through the data is all that's needed. Q2. In the pronoun resolution problem, why are the noun and pronoun lists sorted? Show Answer

The lists are sorted by SerialNo (position in the paragraph). This allows us to efficiently find the nearest preceding noun for each pronoun — we iterate through nouns until we pass the pronoun's position, then exit the loop. Q3. Write pseudocode to build a dictionary mapping product names to their total quantity sold. Show Answer

pseudo
productQty = {}
while (Table 1 has more rows) {
    Read X
    if (isKey(productQty, X.ProductName)) {
        productQty[X.ProductName] = productQty[X.ProductName] + X.Quantity
    }
    else {
        productQty[X.ProductName] = X.Quantity
    }
    Move X
}

Show Answer

DeleteKey modifies the original dictionary directly. DeleteKey2 creates and returns a new dictionary with the key removed, leaving the original unchanged. The caller must reassign the variable if they want the updated dictionary.

Intermediate Questions

• A: DOB=50, B: DOB=120, C: DOB=50, D: DOB=50, E: DOB=120

Show Answer

Duplicates found: DOB 50 and 120 Q6. How would you modify the pronoun resolver to handle cases where a pronoun has no preceding noun? Show Answer

Initialize matched = -1 and only add to matchD if matched ≠ -1:

pseudo
foreach p in partOfSpeech["Pronoun"] {
    matched = -1
    foreach n in partOfSpeech["Noun"] {
        if (n < p) {
            matched = n
        }
        else {
            exitloop
        }
    }
    if (matched ≠ -1) {
        matchD[p] = matched
    }
    // If matched == -1, no noun precedes this pronoun
}

Show Answer

Each city maps to MULTIPLE students. A dictionary value can only hold one value per key, so we use a list to store all students from that city. The dictionary key is the city name, and the value is a list of student names. Q8. Write a procedure to invert a dictionary (swap keys and values). Assume all values are unique. Show Answer

pseudo
Procedure InvertDict(d) {
    inverted = {}
    foreach k in keys(d) {
        v = d[k]
        inverted[v] = k
    }
    return(inverted)
End InvertDict

// Example: InvertDict({"a": 1, "b": 2}) → {1: "a", 2: "b"}

📚 Cross-References

Next Topic: 13 — Graphs Introduction

Quiz Tip: Dictionary problems are common in Quiz 2 and End Term. Practice the "isKey + create/update" pattern! Join Discord PreviousDictionariesNextGraphs & Adjacency Matrices