Why Greedy Works and When It Fails in DSA Python - Test Your Knowledge

Practice - 5 Tasks

1fill in blank

easy

Complete the code to select the next best item greedily based on value.

DSA Python

items = [(60, 10), (100, 20), (120, 30)]  # (value, weight)
items.sort(key=lambda x: x[[1]], reverse=True)
print(items)

Drag options to blanks, or click blank then click option'

A1

B0

C2

D3

Attempts:

3 left

💡 Hint

Common Mistakes

Sorting by weight instead of value.

Using an invalid index like 3.

We sort items by their value (index 0) in descending order to pick the highest value first.

2fill in blank

medium

Complete the code to calculate the value-to-weight ratio for greedy selection.

DSA Python

items = [(60, 10), (100, 20), (120, 30)]
ratios = [item[0] / item[[1]] for item in items]
print(ratios)

Drag options to blanks, or click blank then click option'

A3

B0

C2

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Dividing by value instead of weight.

Using an index out of range.

Weight is at index 1, so dividing value by weight gives the ratio.

3fill in blank

hard

Fix the error in the greedy coin change algorithm to pick the largest coin first.

DSA Python

coins = [1, 5, 10, 25]
coins.sort(reverse=[1])
change = 63
result = []
for coin in coins:
    while change >= coin:
        change -= coin
        result.append(coin)
print(result)

Drag options to blanks, or click blank then click option'

ANone

BFalse

CTrue

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using reverse=False causes smallest coins first.

Using None or 0 causes errors.

Sorting coins in descending order (reverse=True) ensures greedy picks largest coin first.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps words to their lengths only if length > 3.

DSA Python

words = ['apple', 'bat', 'car', 'door']
lengths = {word: [1] for word in words if len(word) [2] 3}
print(lengths)

Drag options to blanks, or click blank then click option'

Alen(word)

B>

C<

Dword

Attempts:

3 left

💡 Hint

Common Mistakes

Using word instead of len(word) as value.

Using '<' instead of '>' in condition.

We map each word to its length (len(word)) only if length is greater than 3.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension filtering items with positive values and keys uppercased.

DSA Python

data = {'a': 1, 'b': -2, 'c': 3}
result = { [1]: [2] for k, v in data.items() if v [3] 0 }
print(result)

Drag options to blanks, or click blank then click option'

Ak.upper()

Bv

C>

Dk.lower()

Attempts:

3 left

💡 Hint

Common Mistakes

Using k.lower() instead of k.upper().

Using '<' instead of '>' in condition.

Keys are uppercased (k.upper()), values kept as v, filtered where value > 0.

Practice

1. What is the main reason a greedy algorithm works correctly for some problems?

easy

A. Because it sorts the input data before processing

B. Because it tries all possible solutions exhaustively

C. Because it uses recursion to explore all paths

D. Because making the best local choice leads to a globally optimal solution

Solution

1. Step 1: Understand greedy algorithm principle

   A greedy algorithm makes the best choice at each step without reconsidering previous choices.

2. Step 2: Connect local choices to global optimum

   For some problems, these local best choices add up to the best overall solution.

3. Final Answer:

   Because making the best local choice leads to a globally optimal solution -> Option D

4. Quick Check:

   Greedy = best local choice leads to global optimum [OK]

Hint: Greedy picks best now, works if global best follows [OK]

Common Mistakes:

• Thinking greedy tries all solutions
• Confusing greedy with recursion
• Assuming sorting always means greedy

2. Which of the following is the correct syntax to pick the next item greedily from a sorted list items in Python?

easy

A. next_item = items.pop(0)

B. next_item = items[0]

C. next_item = items.pop()

D. next_item = items.remove(0)

Solution

1. Step 1: Understand list methods for greedy selection

   To pick and remove the first item, pop(0) removes and returns it.

2. Step 2: Check other options

   items[0] only accesses without removing; pop() removes last; remove(0) removes first occurrence of value 0, not index.

3. Final Answer:

   next_item = items.pop(0) -> Option A

4. Quick Check:

   pop(0) removes first item [OK]

Hint: pop(0) removes and returns first item [OK]

Common Mistakes:

• Using items[0] without removing
• Using pop() removes last item
• Confusing remove() with pop()

3. Consider the following code that tries to select intervals greedily by earliest finish time:

intervals = [(1,4), (2,3), (3,5), (7,8)]
intervals.sort(key=lambda x: x[1])
selected = []
end = 0
for start, finish in intervals:
    if start >= end:
        selected.append((start, finish))
        end = finish
print(selected)

What is the output?

medium

A. [(2, 3), (7, 8)]

B. [(1, 4), (7, 8)]

C. [(2, 3), (3, 5), (7, 8)]

D. [(1, 4), (3, 5), (7, 8)]

Solution

1. Step 1: Sort intervals by finish time

   Sorted intervals: (2,3), (1,4), (3,5), (7,8)

2. Step 2: Select intervals greedily

   Start with end=0. (2,3) start=2 >=0, select it, end=3. Next (1,4) start=1<3 skip. Next (3,5) start=3>=3 select, end=5. Next (7,8) start=7>=5 select, end=8.

3. Step 3: Final selected intervals

   [(2,3), (3,5), (7,8)]

4. Final Answer:

   [(2, 3), (3, 5), (7, 8)] -> Option C

5. Quick Check:

   Greedy interval selection by finish time = [(2,3),(3,5),(7,8)] [OK]

Hint: Sort by finish time, pick intervals starting after last end [OK]

Common Mistakes:

• Not sorting by finish time
• Selecting overlapping intervals
• Updating end incorrectly

4. The following code tries to solve the coin change problem greedily but has a bug:

coins = [25, 10, 5, 1]
amount = 30
result = []
for coin in coins:
    while amount >= coin:
        result.append(coin)
        amount -= coin
print(result)

What is the bug in this greedy approach?

medium

A. It does not sort coins before using them

B. It fails for some coin sets where greedy is not optimal

C. It uses while instead of if

D. It does not handle zero amount correctly

Solution

1. Step 1: Understand greedy coin change approach

   The code picks largest coin repeatedly until amount is zero.

2. Step 2: Identify when greedy fails

   Greedy works for US coins but fails for some sets (e.g., coins=[10,6,1], amount=12 greedy picks 10+1+1=3 coins but optimal is 6+6=2 coins).

3. Final Answer:

   It fails for some coin sets where greedy is not optimal -> Option B

4. Quick Check:

   Greedy coin change fails on some coin sets [OK]

Hint: Greedy coin change fails if coin set is non-canonical [OK]

Common Mistakes:

• Assuming greedy always gives minimum coins
• Thinking sorting is missing
• Confusing while and if usage

5. You want to select the minimum number of intervals to cover a timeline from 0 to 10. Intervals are: [(0,3), (2,6), (5,10), (7,10), (1,4)]. Which greedy strategy will fail to find the minimum set and why? Options: A) Always pick the interval with earliest start time B) Always pick the interval with shortest length C) Always pick the interval with earliest finish time D) Always pick the interval covering the largest uncovered part Choose the failing strategy and explain why.

hard

A. Always picking shortest length fails because it may need many intervals to cover timeline

B. Always picking earliest start fails because it may pick small intervals leaving gaps

C. Always picking earliest finish time works correctly here

D. Always picking largest uncovered part always finds minimum intervals

Solution

1. Step 1: Analyze shortest length strategy

   Picking shortest intervals first may cover small parts, requiring many intervals to cover entire timeline.

2. Step 2: Compare with other strategies

   Earliest finish time is classic greedy that works for interval covering. Largest uncovered part is a complex greedy that can work. Earliest start can fail but less obviously here.

3. Final Answer:

   Always picking shortest length fails because it may need many intervals to cover timeline -> Option A

4. Quick Check:

   Shortest length greedy fails for minimum interval cover [OK]

Hint: Shortest intervals first often leads to many intervals needed [OK]

Common Mistakes:

• Assuming earliest start always works
• Thinking largest uncovered part is always greedy
• Confusing shortest length with earliest finish