u6-script-recursion-generators

Question 2

What will this recursive function return for matrix(2, 3)

def matrix(*args, fill_value: int = 0):
    if not args:
        return []
    if len(args) == 1:
        return [fill_value] * args[0]
    outer = []
    for _ in range(args[0]):
        outer.append(matrix(*args[1:], fill_value=fill_value))
    return outer

Example usage:
result = matrix(2, 3)
print(result)

Answer 2

It will return a list containing 2 inner lists, each containing 3 zeros: [[0, 0, 0], [0, 0, 0]]

Explanation:
The function matrix takes a variable number of dimensions (*args) and an optional fill_value parameter.
If no dimensions are provided (not args), it returns an empty list.
If only one dimension is provided (len(args) == 1), it returns a list of the specified length filled with fill_value.
For multiple dimensions, it recursively creates nested lists.

Example:
For matrix(2, 3), the function will return a 2x3 matrix filled with the default fill_value of 0:

[[0, 0, 0], [0, 0, 0]]

Question 3

What are the base cases in this recursive matrix function

def matrix(*args, fill_value: int = 0):
    if not args:
        return []
    if len(args) == 1:
        return [fill_value] * args[0]
    outer = []
    for _ in range(args[0]):
        outer.append(matrix(*args[1:], fill_value=fill_value))
    return outer

Answer 3

There are two base cases:

Base Case 1: No Dimensions Provided
(empty list for no arguments)

if not args:
    return []

Base Case 2: Single Dimension Provided
(creates a 1D list of the specified length)

if len(args) == 1:
    return [fill_value] * args[0]

Question 4

What would be the output of my_function(“a”, [“b”, [“c”, “d”]], “e”) for this code?

def my_function(*args):
    result = []
    for arg in args:
        if isinstance(arg, str):
            result.append(arg)
        elif isinstance(arg, list):
            result += my_function(*arg)
    return result

Example usage:
output = my_function("a", ["b", ["c", "d"]], "e")

Answer 4

The output would be [‘a’, ‘b’, ‘c’, ‘d’, ‘e’] - it flattens the nested structure into a single list of strings

Question 5

Why is the *arg unpacking crucial in this recursive list flattening?

result += my_function(*arg)

Answer 5

Without the * operator, arg would be passed as a single list argument, causing infinite recursion. With *, the list elements are unpacked and passed as separate arguments

Question 6

What’s the difference between these two generator implementations?

def generator1(my_sequence):
    i = 0
    while True:
        yield my_sequence[i]
        i += 1
        if i >= len(my_sequence):
            i = 0

def generator2(my_sequence):
    while True:
        for elem in my_sequence:
            yield elem

Answer 6

Both achieve the same result of endlessly cycling through the sequence, but the first uses index-based access with manual index management, while the second uses Python’s for-loop iteration. The second version is more Pythonic and easier to read

Question 7

How does this code implement cycling through a sequence using the modulo operator?

yield my_sequence[i % len(my_sequence)]

Answer 7

The modulo operator (%) automatically wraps the index back to 0 when it reaches the sequence length. For example, with a sequence of length 5, the indices would go 0,1,2,3,4,0,1,2,3,4,0,…