Euclidean Rhythm Lab

Learn the pattern. Predict the beats. Reveal the algorithm.

Musicians distribute sound through time. Programmers distribute values through a sequence. In this lab, those are the same problem.

Start the first challenge

01Loops

Repeat one rule across a sequence.

02Modular arithmetic

Wrap positions around a cycle.

03Algorithmic thinking

Turn “evenly spaced” into steps.

Predict before the computer answers

Can you hear the algorithm before you see it?

Classify every position as a beat or a rest. Each press cycles from unknown to beat to rest. Only then can you reveal the pattern.

Challenge 1 of 3

Space three beats

Place 3 beats across 8 steps so the gaps feel as even as possible.

steps: 8
beats: 3
rotate: 0

0 of 8 steps classified

The computer’s sequence

Compare the size of each gap.

Represent

Model a beat as 1 and a rest as 0.

Distribute

Repeatedly group beats with rests until the gaps are balanced.

Rotate

Shift the list with modulo logic while preserving its structure.

Python

def euclidean_rhythm(steps, pulses, rotation=0):
    steps = max(4, min(16, round(steps)))
    pulses = max(1, min(steps, round(pulses)))
    rotation = rotation % steps

    if pulses == steps:
        pattern = [1] * steps
    else:
        counts, remainders = [], [pulses]
        divisor = steps - pulses

        while remainders[-1] > 1:
            counts.append(divisor // remainders[-1])
            remainders.append(divisor % remainders[-1])
            divisor = remainders[-2]
        counts.append(divisor)

        pattern = []
        def build(level):
            if level == -1:
                pattern.append(0)
            elif level == -2:
                pattern.append(1)
            else:
                for _ in range(counts[level]):
                    build(level - 1)
                if remainders[level] != 0:
                    build(level - 2)

        build(len(counts) - 1)
        first_beat = pattern.index(1)
        pattern = pattern[first_beat:] + pattern[:first_beat]

    return [
        pattern[(index - rotation) % len(pattern)]
        for index in range(len(pattern))
    ]

First-principles check: the number of 1s stays fixed, while their positions change to minimize uneven gaps.

Transfer the idea

One pattern, several computer-science lenses.

Sequence

How should values be arranged?

Move from an intuitive goal—“even spacing”—to a concrete list of binary values.

Invariant

What must stay true?

The list length and beat count never change, even when the starting point rotates.

Decomposition

Which smaller operations help?

Count, group, compare gaps, repeat, and rotate: each step can be tested on its own.

For the Brilliant team

Why I designed the lesson this way

Created as a new application demonstration, this prototype shows how I would translate an abstract CS idea into an approachable, interactive problem-solving journey.

Prediction before exposition

Learners commit to a model first, so the reveal produces useful feedback instead of passive recognition.

Concrete before symbolic

Musical beats make distribution visible and audible before the Python representation appears.

Challenge by variation

Each challenge foregrounds a new idea—distribution, density, then rotation—supporting comparison and transfer.

Multiple representations

Grid, sound, binary sequence, prose, and code give learners several ways into the same concept.