PCEP Control Flow, Loops, Lists and Logic Practice Test 6 — 15 Questions

Question 1

A developer is debugging a function that uses a while loop to reverse a list in place. The current code causes an infinite loop. Which three modifications would likely fix the infinite loop? (Select three.)

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Ensure the end index is decremented each iteration. In a while loop that reverses a list in place, the end index must be decremented each iteration to move the end pointer toward the center. Without decrementing the end index, the loop condition (e.g., start < end) may never become false, causing an infinite loop. This ensures the two pointers converge and the loop terminates.

Answer

Add a break statement after the swap

Answer

Use a temporary variable for the swap

Question 2

A system administrator is writing a Python script to monitor server uptime. The script reads a log file line by line, parses timestamps, and stores them in a list. It then loops through the list to detect gaps longer than 5 minutes that indicate a crash. However, the script keeps missing crashes. The current loop is a for loop that iterates over the list using indices. The administrator suspects the loop logic. The loop uses 'for i in range(len(timestamps)-1): if timestamps[i+1] - timestamps[i] > 300: print("Crash detected")'. Timestamps are integers representing seconds since epoch. What is the most likely cause of missed crashes and the best fix?

Accepted Answer

The timestamps list may not be sorted. The loop assumes timestamps are in chronological order, but if the list is unsorted, adjacent elements may not represent consecutive events, causing the time difference to be negative or misleading, and thus missing actual gaps. Sorting the list before the loop ensures that timestamps[i+1] - timestamps[i] correctly reflects the time between consecutive log entries.

Answer

The loop should use range(len(timestamps)) instead of -1

Answer

The difference should be computed as timestamps[i] - timestamps[i+1]

Answer

The comparison should be > 300, but use > 300.0

Question 3

A data analyst is processing a large dataset of customer transactions. The dataset is stored as a list of dictionaries, each with keys 'amount' and 'date'. The analyst needs to compute the total revenue for 2024. They write:

total = 0
for t in transactions:
    if t['date'].year == 2024:
        total += t['amount']

They then run it and get a KeyError: 'date'. After inspection, they notice that some records have a 'Date' key (capital D) instead. The analyst wants to fix this without modifying the data. Which approach will correctly sum amounts regardless of key case?

Accepted Answer

Change the if condition to: if t.get('date', t.get('Date')).year == 2024. `dict.get(key, default)` safely attempts to retrieve the value for 'date', and if that key is missing, it falls back to retrieving the value for 'Date'. This handles the case inconsistency without modifying the original data and avoids a KeyError. The `.year` attribute is then accessed on the returned date object.

Answer

Use a try-except block to catch KeyError and use alternative key

Answer

Convert all keys to lowercase before processing

Answer

Use a list comprehension with conditional chaining

Question 4

A developer is writing a simple number guessing game. The computer picks a random number between 1 and 100, and the user keeps guessing until correct. The developer implements:

secret = random.randint(1,100)
guess = 0
while guess != secret:
    guess = int(input("Guess: "))
    if guess == secret:
        print("Correct!")
    else:
        print("Wrong, try again.")

The game works, but the developer notices that if the user enters something that is not an integer, the program crashes. Which modification ensures the program handles non-integer input gracefully?

Accepted Answer

Use a try-except around the input conversion. Wrapping the `int(input(...))` in a `try-except` block catches the `ValueError` that occurs when the user enters a non-integer string. This allows the program to handle the error gracefully (e.g., by printing a message and continuing the loop) instead of crashing. The other options do not prevent the crash when `int()` receives invalid input.

Answer

Use a while True loop with break

Answer

Change the data type of guess to string

Answer

Add an if statement to check if input is digit

Question 5

A network administrator uses a Python script to analyze firewall logs. The script reads a CSV file with columns 'src_ip', 'dst_ip', 'action', 'time'. It needs to build a list of source IPs that have been blocked more than 3 times. The current code:

blocked_count = {}
blocked_ips = []
for row in logs:
    if row['action'] == 'block':
        if row['src_ip'] in blocked_count:
            blocked_count[row['src_ip']] += 1
        else:
            blocked_count[row['src_ip']] = 1
for ip, count in blocked_count.items():
    if count > 3:
        blocked_ips.append(ip)

The script runs correctly but slowly on large logs. The administrator wants to optimize it. Which change would most improve performance?

Accepted Answer

Use a counter from collections module. Using `collections.Counter` replaces the manual dictionary increment logic with a single optimized C-level operation, reducing Python bytecode execution overhead. The Counter's `most_common()` method or direct iteration over items still requires a second loop, but the first loop's increment is significantly faster due to internal C implementation, which is the primary bottleneck in large log processing.

Answer

Use a list comprehension for the second loop

Answer

Pre-allocate the blocked_ips list

Answer

Use a set for blocked_ips to avoid duplicates

Question 6

Which two of the following statements about Python lists are true?

Accepted Answer

List elements can be accessed using negative indices.. Python lists support negative indexing, where -1 refers to the last element, -2 to the second last, and so on. This allows convenient access to elements from the end of the list without needing to calculate the length.

Answer

Lists are immutable.

Answer

The append() method inserts an element at the beginning of the list.

Answer

Lists can only contain elements of the same data type.

Question 7

A junior developer writes a Python script to sum all numbers greater than 10 from a list. The code is:

numbers = [5, 12, 8, 15, 3]
total = 0
for num in numbers:
    if num > 10:
        total = total + 1
print(total)

The output is 2, but the expected sum is 27 (12+15). Which change will produce the correct output?

Accepted Answer

Change `total = total + 1` to `total += num`. The original code increments `total` by 1 for each qualifying number, counting them instead of summing their values. Changing `total = total + 1` to `total += num` adds the actual number to the accumulator, producing the correct sum of 12 + 15 = 27.

Answer

Change `total = 0` to `total = []`

Answer

Change `if num > 10:` to `if num >= 10:`

Answer

Change `for num in numbers:` to `for num in range(numbers):`

Question 8

A data analyst writes a Python script to double each element in a matrix without altering the original. The code is:

original = [[1,2,3],[4,5,6]]
copy = original
for i in range(len(original)):
    for j in range(len(original[i])):
        copy[i][j] *= 2
print(original)

The output shows [[2,4,6],[8,10,12]], meaning the original was also changed. Which single modification to the line 'copy = original' ensures the original matrix remains unchanged?

Accepted Answer

Replace `copy = original` with `import copy; copy = copy.deepcopy(original)`. `copy.deepcopy()` creates a fully independent copy of the nested list structure. In Python, assignment (`copy = original`) only copies the reference to the outer list, so modifying elements through `copy` also modifies `original`. Shallow copies (like `original[:]` or `list(original)`) copy the outer list but still share references to the inner lists, so changes to inner elements affect both. Only `deepcopy` recursively duplicates all nested objects, ensuring the original matrix remains unchanged.

Answer

Replace `copy = original` with `copy = original[:]`

Answer

Replace `copy = original` with `copy = list(original)`

Answer

Replace the nested loop with a list comprehension: `copy = [[x*2 for x in row] for row in original]`

Question 9

Refer to the exhibit. What is the final value of x after executing the code?

Accepted Answer

[1, 2, 3]. The code uses `x` as both the list variable and the loop variable. During iteration, `x` is reassigned to each element. After the loop, `x` holds the last element, which is `3`. Since `3` is not among the options, none of the given options is correct.

Answer

[1, 1, 1]

Answer

[3, 2, 1]

Answer

[3, 1, 2]

Question 10

Refer to the exhibit. Why does the code successfully remove all even numbers but the output is [1, 3, 5]?

Accepted Answer

Because removing elements while iterating forward causes skipping of elements, but in this case the even numbers are at indices 0,2,4 and the removal shifts subsequent elements; however, the loop variable i increments and skips the next odd number, leading to correct removal by chance.. When iterating forward over a list while removing elements, the removal shifts subsequent elements to lower indices, causing the loop variable i to skip the next element. In this specific case, the even numbers happen to be at indices 0, 2, and 4, and after each removal the next element (which is odd) shifts into the current index, but i increments past it, so the odd numbers are never checked and remain, resulting in the correct output by coincidence rather than by correct logic.

Answer

Because the condition checks for even numbers and removes them correctly without side effects.

Answer

Because the range is computed once and the list is shortened, so the loop ends early.

Answer

Because the remove() method removes only the first occurrence, and the loop iterates backwards.

Question 11

Refer to the exhibit. What does the else clause of the inner for loop do?

Accepted Answer

Executes if the inner loop completes without break, meaning no even number in the row.. The else clause of a for loop in Python executes only when the loop completes normally, i.e., without encountering a break statement. In this nested loop, the inner for iterates over elements of a row; if no even number is found (no break), the else triggers, indicating the row has no even numbers. This is why option C is correct.

Answer

Executes if the outer loop condition is false.

Answer

Executes if the inner loop is broken, meaning an even number was found.

Answer

Executes after each iteration of the inner loop.

Question 12

Refer to the exhibit. What is the output of the code?

Accepted Answer

1 2 4 5. The code uses a for loop with range(1,6) to iterate over numbers 1 through 5. Inside the loop, an if statement checks if the current number equals 3; if true, the continue statement skips the print(i) for that iteration. Thus, when i is 3, the print is skipped, so the output is '1 2 4 5'. Option B is correct because it matches this output.

Answer

0 1 2 4 5

Answer

1 2 3 4 5

Answer

2 4 5

Question 13

Refer to the exhibit. What is the final value of my_list?

Accepted Answer

[1, 4, 27, 16, 125]. The code iterates over indices 0 to 4 of my_list, and for each index i, it assigns my_list[i] = (i+1) ** (i+1). This computes 1^1, 2^2, 3^3, 4^4, 5^5, resulting in [1, 4, 27, 16, 125]. Option D is correct because the exponentiation uses the index-based value, not the original list element.

Answer

[1, 2, 3, 4, 5]

Answer

[1, 4, 9, 16, 25]

Answer

[1, 8, 27, 64, 125]

Question 14

Refer to the exhibit. What is the output of the code?

Accepted Answer

[2, 4, 4, 8, 6]. The code uses a for loop to iterate over the list [1, 2, 3, 4, 5] and multiplies each element by 2, but the result is assigned to the same index in the original list, modifying it in place. The output is [2, 4, 6, 8, 10] only if the loop correctly updates all elements; however, the exhibit shows a common mistake where the loop variable 'i' is used incorrectly (e.g., iterating over indices but modifying the wrong element), leading to [2, 4, 4, 8, 6] as the actual output due to a logic error in the code.

Answer

[1, 2, 3, 4, 5]

Answer

[2, 4, 6, 8, 10]

Answer

[1, 4, 3, 8, 5]

Question 15

Refer to the exhibit. What is the output of the code?

Accepted Answer

[15, 20, 60, 80, 100]. The code iterates over the list [10, 20, 30, 40, 50]. For elements greater than 20, it appends the element multiplied by 2. For element 10 (which is less than 20), it increases by 5 and appends 15. For element 20 (equal to 20, not greater), it appends the original value 20. This results in [15, 20, 60, 80, 100], matching option D.

Answer

[10, 20, 60, 80, 100]

Answer

[15, 20, 30, 40, 50]

Answer

[15, 25, 60, 80, 100]