Coursework 2

In this coursework, you are required to write two Python functions, by filling in code into the template below. Submit your Python script. via upload on Canvas before the deadline on Friday, 21st November 2025 at 2pm.

Working independently

As with all assessed work in this unit, you must complete this coursework independently on your own. You must not take code from elsewhere (including from AI), even if it is referenced. You are however allowed to use the lecture notes and exercise solutions freely, and the lecture notes from weeks 1 to 7 contain all that is required to solve the problems. You are not allowed to ask others for help, and in particular, you are not allowed to send, give, or receive Python code to/from classmates and others.

Instructions

1. Copy the code out of the template below and save it as a .py file in Spyder (or another Python editor of your choice).

2. Add your name, university ID number and university email address in the docstring at top of the file, where indicated

3. Replace the yourcode here comments in the two functions with code to implement the functions euclidean_rhythm and count_pulses, as described in the problems below.

4. Do not alter the names or parameters of these two required functions. Do not create any further functions with the same name. Ensure that these functions can be called with the parameters precisely as specified, and that they return (not print) values of the correct data types.

5. Submit your work on Canvas as a .py Python file. Do not submit a screenshot, PDF, Word document, iPython notebook, or file in any other format.

The coursework will be marked automatically and failure to follow the problem description or any of the instructions above will result in loss of marks.

To check that your code is working correctly, you may wish to add some of your own tests in the main () function.

Only the behaviour of the required functions euclidean_rhythm and count_pulses will be marked; any tests in the main() function will not be marked.

If you wish, you can also add other functions to the code, and call them from the three required functions. Make sure all code (other than module import statements and your call to main()) is within a function.

Do not create any further functions with the same name as any of the required functions.

Do not use the input function anywhere in your code. Make sure your functions return the value they should return, not just print the value to screen.

As this is part of the course assessment, we will not be able to help you solving these problems in the lab classes or elsewhere. If you are unsure what any question is asking for, please ask on the Canvas Discussion Forum.

The code need not be highly optimised, but functions will need to return the correct answer within three seconds in order to obtain the marks.

Rhythms

The idea of patterns distributed as evenly as possible crops up in a surprising range of contexts, ranging from string theory, neutron accelerators Euclid's algorithm and musical rhythms. We will use the musical example here, and call such patterns Euclidean Rhythms.

A rhythm, for the purposes of this coursework, is a number of pulses k ≥ 0 which are allocated among some number n ≥ k of discrete time intervals. We'll denote each time interval by a number, which is 1 if that interval contains a pulse, or 0, if it does not. The rhythm is therefore a list of n numbers, k of which are 1 and the rest 0.

For example, both

1 1 1 1 0 0 0 0

and

1 0 1 0 1 0 1 0

are rhythms with n = 8 and k = 4, corresponding to

and

respectively. There are, of course,

distinct rhythms for a given n and k.

Distributing pulses evenly

Our task will be to generate rhythm where the k pulses are distributed as evenly as possible among the n time intervals. For now we will give some examples to explain informally what as evenly as possible means.

For n = 10 and k = 4, one possible rhythm is

1 1 1 1 0 0 0 0 0 0

The pulses in this rhythm are not evenly spaced, whereas those in

1 0 0 1 0 1 0 0 1 0

are much more evenly spaced. There are three points to note about this rhythm:

1. Because 4 does not divide 10 exactly, the pulses are not all equally spaced, but are spaced as far apart as possible.

2. Musically, we anticipate these rhythms being repeated, so the start of the rhythm follows on the from the end. For that reason, the alternative rhythm with n = 10 and k = 4,

1 0 0 1 0 0 1 0 0 1

while appearing to be more evenly spaced than the rhythm above, is not so when it is repeated:

. . .1 0 0 1 0 0 1 0 0 1 1 0 0 1 0 0 1 0 0 1 . . .

In other words, the rhythm can be considered circular, with the end connected to the start:

3. Distributing pulses as evenly as possible is more complicated than simply maximising the minimum space between adjacent pulses. For the case n= 10, k= 4, the rhythm

1 0 1 0 1 0 0 1 0 0

is less evenly spaced than

1 0 0 1 0 1 0 0 1 0

(even though the pulses are spaced two or three time intervals apart in both cases) because the first five time intervals contains three pulses, whereas the second five contains only one.

Generating rhythms

A simple strategy for generating Euclidean rhythms is as follows. We start with an empty bucket and some counters.

1. For each of the n time intervals in turn (from left to right), we:

a. Add k counters to the bucket.

b. If this causes the number of counters in the bucket to equal or exceed n, mark this time interval with a pulse (as a 1) and remove n counters from the bucket.

c. Otherwise, mark this time interval as a 0.

2. 'Rotate' the rhythm generated by the steps above, by moving final time interval of the rhythm to the start, and shifting the pulses one time interval to the right.

For example, in the case of n = 5, k = 2,

Time interval 1: add 2 counters to bucket. This is smaller than 5, so do not put a pulse in time interval 1.

Time interval 2: add 2 counters to bucket, making 4. This is smaller than 5, so do not put a pulse in time interval 2.

Time interval 3: add 2 counters to bucket, making 6. This is greater or equal to 5, so put a pulse in time interval 3, and remove 5 counters from the bucket leaving 1

Time interval 4: add 2 counters to the bucket, making 3. This is smaller than 5, so do not put a pulse in time interval 4.

Time interval 5: add 2 counters to the bucket, making 5. This is greater or equal to 5, so put a pulse in time interval 5.

Our rhythm is now 00101. We move the final time interval to the start and shifting the others right, to obtain the answer

1 0 0 1 0

Problem 1 (9 marks)

Write a function euclidean_rhythm(n, k) that implements the Euclidean rhythm algorithm described in the previous section, for 0 ≤ k ≤ n.

The function must return a python list of length n containing integers 0 or 1, representing the rhythm in the natural way; that is, the rhythm 1 0 0 1 0 would be represented as a list in Python by [1, 0, 0, 1, 0].

Problem 2 (6 marks)

One way that we might characterise how evenly a rhythm is spaced is to look at some number m of consecutive time intervals, and count how many of these contain pulses.

Write a function count_pulses(r, m, i) that takes

a list r of length n representing a rhythm, containing any combination of the integers o and 1 (like the lists returned by the euclidean_rhythm function)

an integer m, with 0 ≤ m < n

an integer i, with 0 ≤ i ≤ n

The function should return, as an integer, the number of pulses contained in a set of i consecutive time intervals, starting with the mth interval.

The time intervals are labelled starting from 0, so m 0 corresponds to the first (leftmost) time interval.

If m+i exceeds the number of time intervals n then the time intervals considered should 'wrap' around to the start of the rhythm (as in the circular representation of the rhythm)

For example:

count_pulses([1, 0, 0, 1, 0], 0, 3) shouldreturn 1

count_pulses([1, 0, 0, 1, 0], 3, 3) should return 2