Python Coding Challenges & Practice Test

• A1: (b) [1, 2, 3, 4]. b = a binds another name to the same list object, so appending through b mutates the object a also refers to.
• A2: (b) "yth". Slicing s[1:4] includes index 1 up to but not including index 4 — characters at positions 1, 2, 3.
• A3: (b) "nohtyp". A step of -1 walks the string backwards, reversing it.
• A4: (b) [1] then [1, 2]. The default list is created once when the function is defined and shared across calls, so it accumulates values.
• A5: (a) False True False True. Empty containers and 0 are falsy; a non-empty list and a non-empty string (even "0") are truthy.
• A6: (a) 3 3.5 1. // is floor division, / is true (float) division, and % is the remainder.
• A7: (b) 0. dict.get returns the supplied default when the key is missing instead of raising KeyError.
• A8: (b) 3. A set keeps only distinct values, so the duplicates collapse to {1, 2, 3}.
• A9: (a) {0: 0, 1: 1, 2: 4}. A dict comprehension maps each key to its square over range(3).
• A10: (b) -1. int("abc") raises ValueError, which is caught and sets x = -1.

def fizzbuzz(n):
    for i in range(1, n + 1):
        if i % 15 == 0:
            print("FizzBuzz")
        elif i % 3 == 0:
            print("Fizz")
        elif i % 5 == 0:
            print("Buzz")
        else:
            print(i)

Check i % 15 (3 and 5 together) before the individual checks. Runs in O(n) time.

def reverse_words(sentence):
    return " ".join(reversed(sentence.split()))

str.split() with no argument splits on any whitespace and drops empties; reversed reverses the word list and join rebuilds the string. O(n) in the length of the input.

def word_count(text):
    counts = {}
    for word in text.lower().split():
        counts[word] = counts.get(word, 0) + 1
    return counts

# Idiomatic alternative:
# from collections import Counter
# return dict(Counter(text.lower().split()))

dict.get(word, 0) avoids a separate "key exists" check. collections.Counter is the idiomatic standard-library tool. O(n) over the words.

def is_palindrome(s):
    cleaned = [c.lower() for c in s if c.isalnum()]
    return cleaned == cleaned[::-1]

Keep only alphanumeric characters, lowercase them, then compare against the reverse. O(n) time and O(n) extra space.

def two_sum(nums, target):
    seen = {}                      # value -> index
    for i, n in enumerate(nums):
        complement = target - n
        if complement in seen:
            return [seen[complement], i]
        seen[n] = i
    return None

A hash map lets you look up the needed complement in O(1), giving an overall O(n) single-pass solution instead of the O(n²) brute force.

def flatten(items):
    result = []
    for item in items:
        if isinstance(item, list):
            result.extend(flatten(item))
        else:
            result.append(item)
    return result

Recursion handles arbitrary nesting depth: lists are flattened in place via extend, scalars are appended. O(n) in the total number of elements.

def fibonacci(n):
    seq = []
    a, b = 0, 1
    for _ in range(n):
        seq.append(a)
        a, b = b, a + b
    return seq

Tuple assignment a, b = b, a + b advances both values without a temporary variable. Iterative and O(n), avoiding the exponential cost of naive recursion.

class BankAccount:
    def __init__(self, balance=0):
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Deposit must be positive")
        self.balance += amount

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError("Insufficient funds")
        self.balance -= amount

__init__ sets the initial state; withdraw validates funds before mutating and raises ValueError when the request exceeds the balance. Each operation is O(1).