Grade 8 AI & Computer Science Practice Questions — Set 5

ExplanationFirst, the result is [0, 15], because Evaluation: range(20) produces 0,1,2,...,19. The condition x % 3 == 0 and x % 5 == 0 requires both parts true (logical AND). Then, values divisible by 3: 0,3,6,9,12,15,18. Values divisible by 5: 0,5,10,15. Intersection (both conditions true): 0, 15. This demonstrates that 'and' in comprehension conditions enables multi-criteria filtering—the same value must pass all conditions. Mathematically, x % 3 == 0 and x % 5 == 0 is equivalent to x % 15 == 0 (least common multiple). Using 'and' filters for intersection (stricter), while 'or' filters for union (looser). Without multiple conditions, [x for x in range(20) if x % 3 == 0] produces [0,3,6,9,12,15,18]. With 'and': [0,15]. With 'or': [0,3,5,6,9,10,12,15,18]. Finally, comprehensions make such multi-criteria selections readable.

ExplanationFirst, the value 15 is returned by student.get('age'), because the get() method retrieves the value associated with 'age'. Difference from bracket notation: student['age'] returns 15 if the key exists, but raises a KeyError if it is missing. get('age') instead returns 15 if the key exists, or None if it is missing — it never raises an exception. Why this matters: (1) Error handling — code will not crash on a missing key, (2) Default values — get('missing', 'default') can return a fallback like 'default' instead of None, (3) Safety when processing data that may have optional fields. In professional code, get() is the preferred choice whenever a key's presence cannot be guaranteed.

ExplanationFirst, the result is True. data.keys() returns a dict_keys object containing 'x', 'y', 'z'. Then, the expression 'x' in keys checks membership. Since 'x' is indeed a key, the result is True. The keys() method returns a dynamic view of dictionary keys. Membership testing is O(1) average-case on dictionary keys due to hash tables, while on lists it is O(n) linear search. Finally, professional code frequently uses: if user_id in user_database.keys().

Explanationpop('b') removes the key 'b' from the dictionary and returns its value, 2, while modifying the dictionary in place. After the call, d contains {'a': 1, 'c': 3}. Since result is assigned from d, not from the return value of pop(), result equals {'a': 1, 'c': 3}, showing that pop() both removes a key-value pair and hands back the removed value in a single operation.

ExplanationThe dictionary d has three key-value pairs, so d.items() yields three tuples: ('one', 1), ('two', 2), and ('three', 3). The loop header for key, value in d.items(): unpacks each tuple directly into the variables key and value, so print(key, value) outputs 'one 1', 'two 2', and 'three 3' on three separate lines, in insertion order (Python 3.7+ dictionaries preserve insertion order). This unpacking is what makes items() valuable: iterating with for key in d alone exposes only the keys, forcing a separate d[key] lookup to fetch each value, whereas items() retrieves both the key and its value together in a single O(n) pass over the n entries, with no repeated lookups. That is why items() is the standard, PEP 8-recommended way to iterate a dictionary whenever both keys and values are needed.

ExplanationThe values() method returns a dict_values view containing 10 and 20. Converting it with list() gives [10, 20], and sum() adds these together: 10 + 20 = 30. This is why values() is useful for aggregation—it hands over all the values in a dictionary directly, without needing to know or loop through the keys, so operations like sum(), max(), or statistics.mean() can be applied straight to d.values().

ExplanationFirst, the result is 6. The __init__() method initializes self.count = 5. Then increment() executes self.count += 1, changing 5 to 6. Result = c.count = 6. This demonstrates that __init__() runs automatically when Counter(5) is called, initializing instance attributes. Each instance has separate state—c.count and another Counter object's count are independent. Finally, __init__() is critical because it sets up initial state that methods rely on.

ExplanationThe result is True. Car inherits from Vehicle, so instances of Car are also instances of Vehicle from a type perspective. isinstance(c, Vehicle) returns True because Car IS-A Vehicle — Python's isinstance() checks the entire class hierarchy, not just an object's exact class. This is what makes polymorphic code possible: a function like def process(v): if isinstance(v, Vehicle): v.start() works correctly for Car, Truck, or Motorcycle objects since all of them inherit from Vehicle, without the function ever needing to know the specific subclass it received.

ExplanationThe result is 20, because Python's method resolution order (MRO) checks Derived first, finding x = 20, and returns it without checking Base. If Derived did not define x, it would inherit Base.x = 10. MRO order: [Derived, Base, object]. This enables intentional overriding: subclasses can shadow parent attributes. Professional code uses this for configuration: BaseConfig.debug = False; DevelopmentConfig.debug = True enables environment-specific settings through inheritance.

ExplanationFirst, the result is 'Balance: 100', because When str(acc) is called, Python invokes the __str__() method, which returns the formatted string 'Balance: 100'. Without __str__(), str(acc) would return '<BankAccount object at 0x7f...>' (memory address). Then, dunder methods (double-underscore methods) customize behavior for built-in operations. Professional code implements __str__() for all classes to aid debugging and logging.

ExplanationFirst, the result is True, because __new__() controls instance creation (it runs before __init__()). The code checks if _instance exists; if not, it creates the instance and caches it; otherwise it returns the already-cached instance. So c1 and c2 end up referencing the identical object, and c1 is c2 evaluates to True. This is the singleton pattern — it guarantees a class has at most one instance. Common real-world uses include a single Logger for an entire app, a single Configuration object, or a single shared database connection pool.

Explanationjson.dump(data, f) serializes the dictionary to JSON format and writes it to the file. The file ends up containing {"name": "Alice", "age": 15} — Python's single quotes become the double quotes JSON requires, since the JSON specification mandates double quotes around keys and string values. JSON serialization enables data persistence in three ways: it saves program state to disk, it lets other languages parse the same file (interoperability), and it stays human-readable so files can be inspected directly in a text editor.

ExplanationThe result is 'something wrong', because CustomError(msg) creates an exception instance with msg stored as its argument. Raising it with raise generates that exception object, caught as variable e, and str(e) converts it to its message text since Exception's built-in __str__ already returns the constructor arguments as a string, with no override needed. Custom exceptions like this enable domain-specific error handling: a program can write except CustomError: handle_app_error() separately from except ValueError: handle_type_error(), so different failure types trigger different, targeted recovery logic instead of one generic handler treating every error the same way.

ExplanationThe result is True. Inside the except block, traceback.format_exc() captures the current exception's full traceback as a formatted string — the file path, line number, exception type, and message, plus the complete chain of function calls that led to the error. Because cause_error() actually raised an exception that was caught, this string is guaranteed to be non-empty, so len(error_info) > 0 evaluates to True. This is precisely what makes traceback so valuable for debugging: unlike just catching the exception and printing its message, format_exc() preserves the entire call stack, so a developer can see not just what went wrong but exactly which function called which function down to the line that failed. In production systems this trace is usually written to a log file with logging.exception() rather than printed to the console, so it can be reviewed after the program has already moved on.

ExplanationThe result is 'l' because strings are sequences and indexing is 0-based: h=0, e=1, l=2, l=3, o=4, so text[2] returns 'l'. Slicing text[1:3] would give 'el' (the characters at indices 1 and 2), which confirms the same 0-based counting.

ExplanationThe result is 120. Trace: factorial(5) = 5 * factorial(4); factorial(4) = 4 * factorial(3); factorial(3) = 3 * factorial(2); factorial(2) = 2 * factorial(1); factorial(1) = 1 (base case, since n <= 1). The calls then unwind from the base case outward: 1, then 1*2=2, then 2*3=6, then 6*4=24, then 24*5=120. This demonstrates recursion: the function calls itself with a simpler input (n-1) until the base case stops further recursion, and the pending multiplications resolve as each call returns, with the call stack reaching a depth of 5 before unwinding back to the final result.

ExplanationThe result is 5, following the Fibonacci sequence 0, 1, 1, 2, 3, 5. The recursion is inefficient because it recomputes overlapping subproblems: fib(5) calls fib(4) and fib(3), and fib(4) itself calls fib(3) and fib(2), so fib(3) ends up computed 2 times and fib(2) ends up computed 3 times across the full call tree. This redundant branching gives the naive version exponential O(2^n) time complexity. Memoization avoids the repetition by caching each fib(k) the first time it is computed, so every subproblem is solved only once and the total time drops to O(n).

Explanationsorted(arr) returns a new list, [1, 1, 2, 3, 4, 5, 6, 9], sorted in ascending order, while the original arr stays as [3, 1, 4, 1, 5, 9, 2, 6]. This is because sorted() is a built-in function that builds and returns a fresh list rather than modifying its argument, unlike the arr.sort() method, which sorts the list in place and returns None. Assigning sorted_arr = sorted(arr) therefore captures the new sorted list, and result (set equal to sorted_arr) holds that same value: [1, 1, 2, 3, 4, 5, 6, 9]. This demonstrates Python's convention of returning new objects from functions that avoid side effects, keeping arr unchanged and available for further use elsewhere in the program.

ExplanationTracing the array [1, 2, 3, 5, 4]: in pass one (i = 0), comparisons at j = 0, 1, 2 find no out-of-order pairs, but at j = 3 the algorithm compares 5 and 4, swaps them to get [1, 2, 3, 4, 5], and sets swapped = True, so the outer loop does not break. In pass two (i = 1), all three comparisons (1 vs 2, 2 vs 3, 3 vs 4) find the array already ordered, so swapped stays False and the `if not swapped: break` statement fires immediately, skipping the remaining three passes the unoptimized version would have run. This means the outer loop executes exactly two passes instead of five. The swapped flag is what makes this possible: without it, bubble sort always runs its full nested loop structure, giving O(n^2) comparisons regardless of how sorted the input already is. With the flag, an array that is already sorted or just one swap away from sorted — like this one — lets the algorithm detect that no more swaps are needed and stop, which is exactly the condition that produces bubble sort's best-case O(n) time complexity. The worst case, such as a fully reverse-sorted array, still forces all n passes and remains O(n^2).

ExplanationThe result is 2. The three Node objects form a chain: head refers to Node(1), whose .next refers to Node(2), whose .next refers to Node(3). So head.val is 1, head.next.val is 2, and head.next.next.val is 3. This particular line follows two pointer hops directly (head.next.val) rather than looping through the list, so no traversal of the whole structure happens here. Linked lists enable dynamic sizing because each node holds a reference to the next node instead of relying on one contiguous memory block: adding or removing a node just rewires a .next pointer, which is O(1) at a known position, unlike an array-based structure that may need to shift elements or reallocate. The tradeoff is that reaching an arbitrary node still requires walking node-by-node from the head, which is O(n) in the worst case for a full traversal.