Dictionary methods and default values in Swift - Time & Space Complexity

Time Complexity: Dictionary methods and default values

O(n)

Understanding Time Complexity

When using dictionary methods with default values, it's important to know how the time to run the code changes as the dictionary grows.

We want to find out how fast dictionary lookups and updates happen when using default values.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

var counts = [String: Int]()
let words = ["apple", "banana", "apple", "orange", "banana", "apple"]

for word in words {
    counts[word, default: 0] += 1
}
    

This code counts how many times each word appears in the list using a dictionary with default values.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through the words array and updating dictionary entries.
• How many times: Once for each word in the list.

How Execution Grows With Input

Each word causes one dictionary lookup and possibly an update. As the list grows, these operations happen more times.

Input Size (n)	Approx. Operations
10	About 10 lookups and updates
100	About 100 lookups and updates
1000	About 1000 lookups and updates

Pattern observation: The number of operations grows directly with the number of words.

Final Time Complexity

Time Complexity: O(n)

This means the time to count words grows in a straight line as the number of words increases.

Common Mistake

[X] Wrong: "Using default values makes dictionary lookups slower because it adds extra work."

[OK] Correct: The default value is used only when the key is missing, and dictionary lookups are still very fast, so the overall speed stays proportional to the number of words.

Interview Connect

Understanding how dictionary methods work with default values helps you write clear and efficient code, a skill valued in many programming tasks.

Self-Check

"What if we replaced the array with a nested loop over two arrays? How would the time complexity change?"

Practice

1. What does the updateValue(_:forKey:) method do in a Swift dictionary?

easy

A. It updates the value for a given key and returns the old value if it existed.

B. It removes the key and its value from the dictionary.

C. It returns the value for a key or a default if the key is missing.

D. It creates a new dictionary with updated keys.

Solution

1. Step 1: Understand updateValue method purpose

   The updateValue(_:forKey:) method changes the value for a specified key in the dictionary.

2. Step 2: Check return behavior

   This method returns the old value if the key existed, otherwise nil.

3. Final Answer:

   It updates the value for a given key and returns the old value if it existed. -> Option A

4. Quick Check:

   updateValue returns old value or nil [OK]

Hint: Remember updateValue returns old value if key exists [OK]

Common Mistakes:

• Confusing updateValue with removeValue
• Thinking it returns the new value
• Assuming it creates a new dictionary

2. Which of the following is the correct syntax to get a value from a dictionary with a default in Swift?

easy

A. let value = dict[key, default: 0]

B. let value = dict.get(key, default: 0)

C. let value = dict[key] ?? 0

D. let value = dict.value(forKey: key, default: 0)

Solution

1. Step 1: Recall Swift dictionary default value syntax

   Swift dictionaries allow accessing values with a default using dict[key, default: defaultValue].

2. Step 2: Compare options

   let value = dict[key, default: 0] matches the correct syntax. let value = dict[key] ?? 0 uses nil-coalescing but is not the dictionary default syntax.

3. Final Answer:

   let value = dict[key, default: 0] -> Option A

4. Quick Check:

   Use dict[key, default:] for default values [OK]

Hint: Use square brackets with default: for safe dictionary access [OK]

Common Mistakes:

• Using get() method which doesn't exist
• Confusing nil-coalescing with dictionary default syntax
• Using value(forKey:) which is for NSObject

3. What is the output of this Swift code?

var scores = ["Alice": 10, "Bob": 8]
let oldValue = scores.updateValue(12, forKey: "Alice")
let missingValue = scores.updateValue(5, forKey: "Charlie")
print(oldValue, missingValue, scores)

medium

A. nil Optional(5) ["Alice": 12, "Bob": 8, "Charlie": 5]

B. 10 5 ["Alice": 12, "Bob": 8, "Charlie": 5]

C. Optional(10) nil ["Alice": 12, "Bob": 8, "Charlie": 5]

D. Optional(12) Optional(5) ["Alice": 10, "Bob": 8, "Charlie": 5]

Solution

1. Step 1: Understand updateValue return values

   Updating "Alice" from 10 to 12 returns old value Optional(10). Adding "Charlie" returns nil because key was missing.

2. Step 2: Check dictionary after updates

   Dictionary now has "Alice":12, "Bob":8, and "Charlie":5.

3. Final Answer:

   Optional(10) nil ["Alice": 12, "Bob": 8, "Charlie": 5] -> Option C

4. Quick Check:

   updateValue returns old value or nil [OK]

Hint: updateValue returns old value wrapped in Optional or nil if new key [OK]

Common Mistakes:

• Expecting updateValue to return new value
• Forgetting Optional wrapping
• Not updating dictionary correctly

4. Identify the error in this Swift code snippet:

var dict = ["a": 1, "b": 2]
let removed = dict.removeValue(forKey: "c")
print(removed!)

medium

A. Dictionary keys must be integers, not strings.

B. Force unwrapping removed causes runtime crash if key missing.

C. removeValue(forKey:) does not exist for dictionaries.

D. print statement syntax is incorrect.

Solution

1. Step 1: Understand removeValue return type

   removeValue(forKey:) returns an Optional value. If key is missing, it returns nil.

2. Step 2: Analyze force unwrapping

   Force unwrapping removed! when key "c" is missing causes a runtime crash.

3. Final Answer:

   Force unwrapping removed causes runtime crash if key missing. -> Option B

4. Quick Check:

   Force unwrap nil causes crash [OK]

Hint: Avoid force unwrapping optional from removeValue without check [OK]

Common Mistakes:

• Assuming removeValue always returns a value
• Ignoring optional unwrapping
• Thinking removeValue removes all keys

5. You have a dictionary var inventory = ["apple": 3, "banana": 5]. Write code to safely add 2 to the count of "orange", even if it doesn't exist yet, using dictionary default values. What is the correct way?

hard

A. inventory["orange"] = inventory["orange"]! + 2

B. inventory["orange"] = inventory["orange"] ?? 0 + 2

C. inventory.updateValue(inventory["orange"]! + 2, forKey: "orange")

D. inventory["orange"] = inventory["orange", default: 0] + 2

Solution

1. Step 1: Understand safe addition with default

   Using inventory["orange", default: 0] returns 0 if "orange" key is missing.

2. Step 2: Increment value safely

   Adding 2 to this default value and assigning back to inventory["orange"] updates or creates the key safely.

3. Final Answer:

   inventory["orange"] = inventory["orange", default: 0] + 2 -> Option D

4. Quick Check:

   dict[key] = dict[key, default: 0] + value for safe increments [OK]

Hint: Use dict[key] = dict[key, default: 0] + amount to add safely [OK]

Common Mistakes:

• Force unwrapping missing keys causing crash
• Using += on read-only default subscript
• Using updateValue without checking for nil