Choosing the right data structure in Intro to Computing - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a list that can store multiple items.

Intro to Computing

my_collection = [1]

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

A[]

B{}

C()

D''

Attempts:

3 left

💡 Hint

Common Mistakes

Using curly braces creates a set or dictionary, not a list.

Using parentheses creates a tuple, which is similar but not the same.

Lists in programming are like shopping bags where you can put many items in order. The square brackets [] create an empty list.

2fill in blank

medium

Complete the code to add a new item to the end of the list.

Intro to Computing

my_list = [1, 2, 3]
my_list.[1](4)

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

Ainsert

Bextend

Cadd

Dappend

Attempts:

3 left

💡 Hint

Common Mistakes

Using insert requires a position index.

Using add is for sets, not lists.

Using extend adds multiple items from another list.

The append method adds a single item to the end of a list, like putting a new book at the end of a shelf.

3fill in blank

hard

Fix the error in the code to access the value for key 'name' in the dictionary.

Intro to Computing

person = {'name': 'Alice', 'age': 30}
print(person[1]'name')

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

A(

B[

C{

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using parentheses causes a syntax error.

Curly braces are for creating dictionaries, not accessing values.

Dictionaries use square brackets [] to access values by their keys, like looking up a word in a dictionary book.

4fill in blank

hard

Complete the code to create a dictionary comprehension that maps words to their lengths for words longer than 3 letters.

Intro to Computing

{word: len(word) for word in words if len(word) [1] 3}

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

A:

B>

C<

D=

Attempts:

3 left

💡 Hint

Common Mistakes

Using = instead of : causes syntax errors.

Using < filters shorter words, not longer.

In dictionary comprehensions, : separates keys and values. The condition > filters words longer than 3 letters.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps uppercase keys to their values for items with positive values.

Intro to Computing

result = [1]: [2] for k, v in data.items() if v [3] 0}

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

Ak.upper()

Bv

C>

Dk

Attempts:

3 left

💡 Hint

Common Mistakes

Using k instead of k.upper() keeps keys unchanged.

Using < filters negative values, not positive.

This comprehension creates keys in uppercase using k.upper(), keeps values as v, and filters items with values greater than zero using >.

Practice

1. Which data structure should you use if you want to store a list of items where order matters and duplicates are allowed?

easy

A. List or array

B. Set

C. Dictionary

D. Tuple

Solution

1. Step 1: Understand the need for order and duplicates

   Lists and arrays keep the order of items and allow duplicates, which matches the requirement.

2. Step 2: Compare with other structures

   Sets do not allow duplicates, dictionaries store key-value pairs, and tuples are immutable but also keep order.

3. Final Answer:

   List or array -> Option A

4. Quick Check:

   Order + duplicates = List/array [OK]

Hint: Use lists for ordered data with duplicates [OK]

Common Mistakes:

• Choosing set which removes duplicates
• Choosing dictionary which stores key-value pairs
• Confusing tuple immutability with order

2. Which of the following is the correct way to create an empty set in Python?

easy

A. empty_set = {}

B. empty_set = set()

C. empty_set = []

D. empty_set = ()

Solution

1. Step 1: Recall syntax for empty set

   In Python, {} creates an empty dictionary, not a set.

2. Step 2: Identify correct set creation

   Using set() creates an empty set correctly.

3. Final Answer:

   empty_set = set() -> Option B

4. Quick Check:

   Empty set = set() [OK]

Hint: Use set() to create empty sets, {} is a dict [OK]

Common Mistakes:

• Using {} which creates an empty dictionary
• Using [] which creates a list
• Using () which creates a tuple

3. What will be the output of this Python code?

data = {'apple': 3, 'banana': 5, 'orange': 2}
print(data['banana'])

medium

A. 5

B. 3

C. 'banana'

D. KeyError

Solution

1. Step 1: Understand dictionary key-value access

   In the dictionary, 'banana' is a key with value 5.

2. Step 2: Access the value for 'banana'

   Using data['banana'] returns the value 5.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   Dictionary key 'banana' = 5 [OK]

Hint: Dictionary[key] returns the value for that key [OK]

Common Mistakes:

• Confusing key with value
• Expecting the key name as output
• Mistyping key causing KeyError

4. You want to store unique user IDs and quickly check if a user ID exists. Which data structure is best? The code below has an error. Find and fix it.

user_ids = []
user_ids.add(101)
user_ids.add(102)

medium

A. Use dictionary instead of list

B. Use append instead of add: user_ids.append(101)

C. Change list to set: user_ids = set()

D. No error, code is correct

Solution

1. Step 1: Identify the error in method usage

   Lists do not have an add() method; add() is for sets.

2. Step 2: Choose correct data structure for unique items

   Sets store unique items and support add() method, so change list to set.

3. Final Answer:

   Change list to set: user_ids = set() -> Option C

4. Quick Check:

   Unique items + add() = set [OK]

Hint: Use set() for unique items and add() method [OK]

Common Mistakes:

• Using add() on list causing AttributeError
• Using append() but duplicates allowed
• Choosing dictionary unnecessarily

5. You have a list of student names with possible duplicates. You want to count how many times each name appears. Which data structure is best and why?

hard

A. Use a tuple to store names immutably

B. Use a set to store unique names only

C. Use a list to store all names again

D. Use a dictionary to map names to counts

Solution

1. Step 1: Understand the need to count occurrences

   Counting requires storing each name with its count, which is a key-value pair.

2. Step 2: Choose data structure for key-value pairs

   Dictionaries store keys (names) with values (counts), perfect for this task.

3. Final Answer:

   Use a dictionary to map names to counts -> Option D

4. Quick Check:

   Counting items = dictionary [OK]

Hint: Use dictionary for counting items with keys and values [OK]

Common Mistakes:

• Using set which removes duplicates and loses counts
• Using list which doesn't map names to counts
• Using tuple which is immutable and not for counting