Question

this works for me but I don’t understand how it works at all. Could anyone explain?

for(int round = 0; round < rounds_count; round++)
{
    for(int match = 0; match < matches_per_round; match++)
    {
        int home = (round + match) % (teams_count - 1);
        int away = (teams_count - 1 - match + round) % (teams_count - 1);

        if(match == 0)
            away = teams_count - 1;

        matches.push_back(Match(&teams[home], &teams[away], round));
    }
}

What’s the trick with modulo?

Answer 1

I’m not sure why this would be using teams_count-1 instead of teams_count, but in general, the modulus is making it “wrap around” so that if round+match is greater than the last team number, it will wrap back ground to one of the first teams instead of going past the last team.

The way away is handled, is a bit special. The % operator doesn’t wrap around the way you want when you have negative numbers. For example -1 % 5 gives you -1 instead of 4. A trick to get around this problem is to add your divisor. (-1+5)%5 gives you 4.

Let’s rework the code a little to make it clearer. First I’ll use another variable n to represent the number of teams (again I’m not sure why teams_count-1 is used for this in your code):

int n = teams_count-1;
int home = (round + match) % n;
int away = (n - match + round) % n;

Then I’ll reorganize the away calculation a little:

int n = teams_count-1;
int home = (round + match) % n;
int away = (round - match + n) % n;

It should now be clearer that the home team is starting with the current round and then adding the match, while the away team is starting with the current round and subtracting the match. The % n makes it wrap around, and the + n for away makes it wrap around properly with negative numbers