## Problem 5: Remainder Generator Like functions, generators can also be higher-order. For this problem, we will be writing `remainders_generator`, which yields a series of generator objects. `remainders_generator` takes in an integer `m`, and yields `m` different generators. The first generator is a generator of multiples of `m`, i.e. numbers where the remainder is 0. The second is a generator of natural numbers with remainder 1 when divided by `m`. The last generator yields natural numbers with remainder `m - 1` when divided by `m`. Note that different generators should not influence each other. > Hint: Consider defining an inner generator function. Each yielded generator varies only in that the elements of each generator have a particular remainder when divided by m. What does that tell you about the argument(s) that the inner function should take in? ```python def remainders_generator(m): """ Yields m generators. The ith yielded generator yields natural numbers whose remainder is i when divided by m. >>> import types >>> [isinstance(gen, types.GeneratorType) for gen in remainders_generator(5)] [True, True, True, True, True] >>> remainders_four = remainders_generator(4) >>> for i in range(4): ... print("First 3 natural numbers with remainder {0} when divided by 4:".format(i)) ... gen = next(remainders_four) ... for _ in range(3): ... print(next(gen)) First 3 natural numbers with remainder 0 when divided by 4: 4 8 12 First 3 natural numbers with remainder 1 when divided by 4: 1 5 9 First 3 natural numbers with remainder 2 when divided by 4: 2 6 10 First 3 natural numbers with remainder 3 when divided by 4: 3 7 11 """ "*** YOUR CODE HERE ***" ``` Note that if you have implemented this correctly, each of the generators yielded by `remainder_generator` will be infinite - you can keep calling next on them forever without running into a `StopIteration` exception.

Here's the implementation of the `remainders_generator` function:

def remainders_generator(m):
    def inner_generator(r):
        """
        Yields natural numbers with remainder when divided by m.
        """
        i = r
        while True:
            yield i
            i += m
    
    for r in range(m):
        yield inner_generator(r)

The `remainders_generator` function takes an integer `m` as input and defines an inner generator function `inner_generator`. This inner function yields natural numbers with remainder `r` when divided by `m`. It does this by starting with `i = r` and repeatedly adding `m` to `i` and yielding the result.

The `remainders_generator` function then loops over `r` from `0` to `m-1` and yields `m` different instances of the `inner_generator` function, one for each possible remainder. Each yielded generator will produce an infinite sequence of natural numbers with the corresponding remainder.

Here's how you can use the `remainders_generator` function:

# Test the remainders_generator function
remainders_four = remainders_generator(4)
for i in range(4):
    print("First 3 natural numbers with remainder {0} when divided by 4:".format(i))
    gen = next(remainders_four)
    for j in range(3):
        print(next(gen))

This code will output:

First 3 natural numbers with remainder 0 when divided by 4:
0
4
8
First 3 natural numbers with remainder 1 when divided by 4:
1
5
9
First 3 natural numbers with remainder 2 when divided by 4:
2
6
10
First 3 natural numbers with remainder 3 when divided by 4:
3
7
11

As expected, the first generator produces multiples of 4, the second produces numbers with remainder 1, the third produces numbers with remainder 2, and the fourth produces numbers with remainder 3.