Why data structures matter for efficiency in Intro to Computing - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a list of numbers from 0 to 5.

Intro to Computing

numbers = list(range([1]))

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

A1

B5

C6

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using 5 as the stop value will exclude 5 from the list.

Using 0 as the stop value will create an empty list.

The range(6) function generates numbers from 0 up to 5, so the list will contain numbers 0 to 5. Since we want numbers 1 to 5, we will adjust in later tasks.

2fill in blank

medium

Complete the code to create a dictionary that maps numbers to their squares for numbers 1 to 5.

Intro to Computing

squares = {x: x[1]2 for x in range(1, [2])}

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

A**

B*

C6

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Using * instead of ** will multiply but not square.

Using range(1, 5) will exclude 5.

The ** operator is used for exponentiation in Python. The range(1, 6) generates numbers from 1 to 5.

3fill in blank

hard

Fix the error in the code to check if a value exists in a list.

Intro to Computing

if [1] in my_list:
    print("Found it!")

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

Avalue

Bindex

Cin

Dmy_list

Attempts:

3 left

💡 Hint

Common Mistakes

Using the list name instead of the value to check.

Using keywords like 'in' or 'index' incorrectly.

To check if a value is in a list, you use the syntax value in list. Here, value is the item you want to find.

4fill in blank

hard

Fill both blanks to create a set of unique numbers from a list.

Intro to Computing

unique_numbers = set([1])
print(len([2]))

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

Anumbers

Bunique_numbers

Clist

Dset

Attempts:

3 left

💡 Hint

Common Mistakes

Using list or set as variable names incorrectly.

Mixing up the variable names in the print statement.

The set() function creates a set of unique elements from the list numbers. Then, len(unique_numbers) gives the count of unique numbers.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension filtering even numbers and mapping to their squares.

Intro to Computing

even_squares = { [1]: [2] for [3] in range(1, 11) if [3] % 2 == 0 }

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

Ax

Bx**2

Dn

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variable names inconsistently.

Not squaring the number for the value.

The dictionary comprehension uses x as the key and x**2 as the value for even numbers x from 1 to 10.

Practice

1. Why is choosing the right data structure important for efficiency?

easy

A. It makes the code look more colorful.

B. It helps perform tasks faster and saves resources.

C. It increases the size of the program.

D. It makes the program run slower.

Solution

1. Step 1: Understand the role of data structures

   Data structures organize data in ways that make accessing and modifying data easier and faster.

2. Step 2: Connect efficiency to task performance

   Choosing the right structure reduces time and resources needed to complete tasks.

3. Final Answer:

   It helps perform tasks faster and saves resources. -> Option B

4. Quick Check:

   Right data structure = faster tasks [OK]

Hint: Right data structure means faster and easier tasks [OK]

Common Mistakes:

• Thinking data structures only affect code appearance
• Believing all data structures perform the same
• Ignoring the impact on program speed

2. Which of the following is the correct way to declare a list in Python?

easy

A. myList = [1, 2, 3]

B. myList = (1, 2, 3)

C. myList = {1, 2, 3}

D. myList = <1, 2, 3>

Solution

1. Step 1: Identify Python list syntax

   Lists in Python are declared using square brackets [].

2. Step 2: Compare options to syntax

   myList = [1, 2, 3] uses square brackets, so it is correct.

3. Final Answer:

   myList = [1, 2, 3] -> Option A

4. Quick Check:

   Python list = square brackets [OK]

Hint: Lists use square brackets [] in Python [OK]

Common Mistakes:

• Using curly braces {} which create sets
• Using parentheses () which create tuples
• Using angle brackets <> which are invalid

3. Consider this Python code:

my_dict = {'a': 1, 'b': 2, 'c': 3}
print(my_dict['b'])

What will be the output?

medium

A. 2

B. Error

C. 'b'

D. 1

Solution

1. Step 1: Understand dictionary key access

   Accessing a dictionary value uses the key inside square brackets.

2. Step 2: Find value for key 'b'

   Key 'b' maps to value 2 in the dictionary.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Dictionary['b'] = 2 [OK]

Hint: Dictionary keys give values, not keys [OK]

Common Mistakes:

• Confusing key with value
• Expecting the key itself as output
• Thinking it causes an error

4. This code tries to add an element to a tuple:

my_tuple = (1, 2, 3)
my_tuple.append(4)

What is the problem?

medium

A. The syntax for append is incorrect.

B. The variable name is invalid.

C. Tuples can only contain strings.

D. Tuples do not support the append method.

Solution

1. Step 1: Recall tuple properties

   Tuples are fixed-size and immutable; they cannot be changed after creation.

2. Step 2: Understand append method limitation

   Append is a list method; tuples do not have it, so this causes an error.

3. Final Answer:

   Tuples do not support the append method. -> Option D

4. Quick Check:

   Tuples immutable = no append [OK]

Hint: Tuples are fixed; only lists can append [OK]

Common Mistakes:

• Thinking append syntax is wrong
• Believing tuples can be changed
• Confusing variable name issues

5. You need to store a large list of unique user IDs and check quickly if a user ID exists. Which data structure is best and why?

hard

A. List, because it keeps order and is easy to search.

B. Dictionary, because it stores key-value pairs efficiently.

C. Set, because it stores unique items and allows fast membership tests.

D. Tuple, because it is immutable and uses less memory.

Solution

1. Step 1: Identify requirements

   We need to store unique IDs and check existence quickly.

2. Step 2: Match data structure features

   Sets store unique items and allow very fast membership checks.

3. Step 3: Compare other options

   Lists are slower for membership; dictionaries store key-value pairs, not just keys; tuples are immutable but slow for membership tests.

4. Final Answer:

   Set, because it stores unique items and allows fast membership tests. -> Option C

5. Quick Check:

   Unique + fast check = Set [OK]

Hint: Use sets for unique items and fast membership [OK]

Common Mistakes:

• Choosing list for fast membership
• Confusing dictionary use for key-value pairs
• Thinking tuple is best for uniqueness