Grade 8 AI & Computer Science Practice Questions — Set 1

ExplanationFirst, the result is 11 because operator precedence rules apply everywhere in Python, including function returns. The expression a + b * 2 is evaluated as a + (b * 2) = 5 + (3 * 2) = 5 + 6 = 11. Then, since multiplication (*) has higher precedence than addition (+), the multiplication executes first. This is why understanding operator precedence is critical even within function definitions—it prevents silent bugs where developers might expect (a + b) * 2 = 16 instead of the correct 11.

ExplanationFirst, the output is 'greater' because when x=10, the condition x > 5 is true, so the first if block executes printing 'greater'. Once a condition is true and its block executes, Python skips all remaining elif and else blocks. Then, this is why understanding if-elif-else flow is critical: conditions are checked in order, and only the first matching block runs. This prevents unexpected behavior where multiple blocks might execute, and it's essential for writing correct decision-making logic in programs.

ExplanationFirst, the value 15 is retrieved because dictionaries use keys to map to values: my_dict['age'] accesses the value associated with the 'age' key, which is 15. Unlike lists that use numeric indices (0, 1, 2..), dictionaries use meaningful keys (strings, numbers, etc.) for access. Then, this provides O(1) average-case lookup time by key and makes code self-documenting—reading my_dict['age'] is clearer than my_list[1]. Dictionaries are superior for storing related data where the key has semantic meaning, making them essential for real-world data structures.

ExplanationFirst, the result is 5 because lower() transforms 'HELLO' to 'hello' without changing character count (still 5 characters), then len() counts these 5 characters. String methods like lower() modify content (uppercase to lowercase) but preserve string length unless explicitly designed to add/remove characters. Then, this demonstrates a critical principle: method chains don't alter structure unless specifically designed to do so. Understanding this prevents bugs where developers might expect length changes from case conversions.

ExplanationFirst, the result is 20.0 because sum([10, 20, 30]) = 60, len() = 3, and 60 / 3 = 20.0. This function is reusable because it accepts any list as input without modification—it works for [10, 20, 30], [5, 15], or any numeric sequence. Then, the function design encapsulates the averaging logic, allowing it to be called repeatedly with different data. This is why abstraction through functions is fundamental: it enables code reuse, reduces bugs (logic is tested once), and makes programs more maintainable.

ExplanationThe result is 120 because of recursive decomposition: factorial(5) = 5 * factorial(4), which calls factorial(4) = 4 * factorial(3), continuing until factorial(1) = 1 (base case). Then the call stack unwinds: factorial(2) = 2 * 1 = 2, factorial(3) = 3 * 2 = 6, factorial(4) = 4 * 6 = 24, factorial(5) = 5 * 24 = 120.

ExplanationFirst, the result is [1, 2, 5, 8] because sort() modifies numbers in-place, rearranging from [5, 2, 8, 1] to [1, 2, 5, 8]. The distinction from sorted() is critical: sort() returns None but modifies the original list, while sorted() returns a new sorted list without modifying the original. Then, sort() is memory-efficient for large lists (no copy overhead) but destructive—you lose the original order. sorted() is safer when you need both versions. This demonstrates trade-offs: memory efficiency versus data preservation. Finally, understanding which to use prevents data loss bugs.

ExplanationFirst, the final number is 0 because int('abc') raises ValueError—strings containing non-numeric characters cannot convert to integers. The except ValueError clause catches this specific exception type and executes number = 0. Then, selective exception handling is critical because different errors require different recovery strategies: ValueError suggests invalid input (set default), IOError suggests file access issues (retry or fail gracefully), ConnectionError suggests network issues (reconnect). Catching all exceptions with bare except is dangerous—it hides unexpected errors. Finally, specific exception handling demonstrates defensive programming: anticipating known failure modes and recovering appropriately.

ExplanationThe function returns True for palindromes and False otherwise. For example, is_palindrome('race car') first lowercases and strips the space to get 'racecar', then compares 'racecar' == 'racecar'[::-1], which is 'racecar' == 'racecar', so the function returns True. For a non-palindrome like 'hello', cleaned is 'hello' and cleaned[::-1] is 'olleh', so 'hello' == 'olleh' is False. The function demonstrates method chaining: s.lower().replace(' ', '') applies two string methods in sequence to normalize the input before comparison. The comparison cleaned == cleaned[::-1] uses slice reversal ([::-1]) to reverse the string without writing an explicit loop, then checks equality directly against the original cleaned string. This combination of normalization (lowercasing, removing spaces) followed by reversal comparison is what makes the function correctly identify inputs such as 'racecar' or 'a man a plan a canal panama' as palindromes while rejecting strings that are not.

ExplanationFirst, the alice_age is 15 because nested indexing allows traversal: users[0] accesses the first dictionary, then ['age'] accesses the 'age' key within that dictionary. This demonstrates how lists of dictionaries create complex structures—users is a list of dictionaries, each representing a person with multiple attributes. Then, nested indexing is essential for real-world data: databases return lists of records (dictionaries), JSON APIs return nested structures, etc. Understanding nested access prevents IndexError and KeyError bugs. Finally, complex data manipulation (filtering, sorting, transforming) depends on comfortable navigation of nested structures.

ExplanationThe number 5 is printed because of lexical scoping: when inner() references x, Python searches (1) local scope (not found), then (2) the enclosing scope (found x=5 in outer()), and uses that value. This demonstrates Python's scope resolution order (LEGB: Local, Enclosing, Global, Built-in), which is how lexical scoping lets inner functions read variables defined in their enclosing outer function without those variables being passed in as parameters.

Explanationnumbers[0] = 64 is the pivot. The comprehension smaller = [x for x in numbers if x < pivot] scans [64, 34, 25, 12, 22, 11, 90] and keeps every value less than 64, giving [34, 25, 12, 22, 11]. The comprehension larger = [x for x in numbers if x >= pivot] keeps every value greater than or equal to 64, giving [64, 90]. This split -- every element sorted into "less than pivot" or "at least pivot" -- is exactly quicksort's partitioning step: each sublist would then be recursively partitioned around its own new pivot until the whole list is sorted.

ExplanationFirst, the result is [2, 4, 6, 8, 10] because map(lambda x: x * 2, data) applies the lambda function to each element, creating a map object, and list() converts it to a list. Lambdas are anonymous functions: lambda x: x * 2 is equivalent to def f(x): return x * 2. Then, map() is a functional programming construct enabling data transformation without explicit loops. This is equivalent to the list comprehension [x * 2 for x in data] but demonstrates functional style. Understanding functional patterns (map, filter, reduce) is important for: processing streams, parallel operations, and expressing intent clearly. Finally, modern Python favors comprehensions over map, but both are valuable approaches.

ExplanationThe result is 'Good' because average = (85+90+78+92+88)/5 = 433/5 = 86.6. This matches elif average >= 80 (86.6 >= 80 is true) and fails if average >= 90 (86.6 >= 90 is false), so 'Good' executes. This demonstrates decision-making based on computed values: calculate first, then use results for conditional logic. Real-world applications: grade assignment (this example), performance scoring, eligibility determination, risk assessment. Understanding the flow is critical: if-elif-else checks conditions in order, executing only the first match. If conditions overlap, order matters—this design is intentional: first check highest threshold, then lower ones, creating a cascade.

ExplanationTracing the code: in 'Python is great', 'Python ' occupies indices 0-6, so text.find('is') scans the string and returns 7, the index where the substring 'is' begins. The slice text[7:9] (since start+2 = 9) then extracts the characters at positions 7 and 8, giving 'is' — slice end bounds are exclusive, so start+2 grabs exactly two characters from the starting index. This shows how find() locates a substring's starting position so a slice can extract it directly, instead of scanning the string character by character by hand.

ExplanationEntering '0' triggers ZeroDivisionError and prints 'Cannot divide by zero' because int('0') successfully converts to 0, then 10 / 0 raises the exception during division. Entering 'abc' triggers ValueError and prints 'Invalid number' because int('abc') fails to convert the non-numeric string, so the error occurs before division is even attempted. The two except clauses let the program distinguish these failure types: the ValueError branch fires only when conversion fails, while the ZeroDivisionError branch fires only when conversion succeeds but the resulting value is zero — so each error type gets its own targeted response instead of one generic message.

ExplanationThe naive recursive Fibonacci has O(2^n) time complexity because each call branches into two subcalls, creating an exponential tree. For fib(35), this means approximately 2^35 ≈ 34 billion operations. The iterative approach runs in O(n) = 35 steps because it computes each value exactly once using two tracking variables. This is why memoization or iteration is essential — the exponential blowup makes naive recursion impractical for n > 30.

ExplanationFirst, merge sort divides the array in half recursively until single elements remain. For [38, 27, 43, 3]: divide into [38, 27] and [43, 3], then further divide to [38], [27], [43], [3]. Then, during merge, pairs are compared and sorted: [27, 38] and [3, 43]. Final merge compares from both sorted halves to produce [3, 27, 38, 43]. The algorithm creates log(n) division levels (log(4) = 2) and performs O(n) work at each level, resulting in O(n log n) time. Option B incorrectly describes division. Option C incorrectly claims merging needs no comparisons. Option D is incorrect about space; merge sort uses O(n) extra space, not O(n^2).

ExplanationFirst, the output is [1, 2, 3, 4] because y = x makes y a reference to the same list object in memory, not a copy. When you append 4 to y, you're modifying the original list because x and y point to the same object. Then, to create independent copies, use x.copy(), x[:], or list(x), which create new list objects with copied elements. This distinction between reference assignment and object copying is critical for avoiding subtle bugs. Option B is false; assignment creates references, not copies. Option C uses non-existent deepcopy method at the list level (deepcopy exists in copy module for nested structures). Option D correctly identifies this behavior. Finally, understanding references versus copies is fundamental to debugging Python programs.

ExplanationComputing fibonacci(n) only ever involves n+1 distinct subproblems: fibonacci(0), fibonacci(1), ..., fibonacci(n). The very first time fibonacci(2) is requested, it is computed and its result is stored in the cache; every later request for fibonacci(2) elsewhere in the recursion tree — and without memoization there can be exponentially many such requests, since the naive recursion tree branches into two calls at every level — is now answered with a single dictionary lookup instead of a fresh recomputation. Since each of the n+1 unique values is computed exactly once, total work scales linearly with n, giving O(n) time (in exchange for O(n) extra space to hold the cache). The claim that memoization converts the recursion into a simple loop is wrong: that would be dynamic programming/iteration, a different technique, and memoization keeps the recursive calls intact. It's also wrong to treat fibonacci(2) as a hardcoded base case — only fibonacci(0) and fibonacci(1) are base cases. fibonacci(2) is genuinely computed once; it is cached, not hardcoded. The claim that each branch keeps its own independent cache is wrong: the cache is shared across the whole computation, not duplicated per branch. If every branch kept its own private cache, the exponential redundancy across branches would never be eliminated, and there would be no speedup at all — the shared cache is precisely what removes the redundant recomputation. The claim that cached values are discarded immediately after use is wrong: memoization must keep every computed value from fibonacci(0) through fibonacci(n) available for the rest of the computation, since any later call might still need it. That is why memoization costs O(n) space, not O(1); the O(n) time saving is bought with O(n) space, the classic time-space tradeoff, not a free optimization.