can anyone helps me.

thank you

I believe what you are asking here is implementation of Round Robin Tournament scheduling using C language.

if(this is the case)

{

```
I guess you can refer to this link for a deeper understanding of the algorithm
http://www.math.niu.edu/~rusin/known-math/97/roundrobin
Now, for implementation, I am explaining it in C# language, I hope conversion into C is not much of a
problem.
public void ListMatches(List<string> ListTeam)
{
if (ListTeam.Count % 2 != 0)
{
ListTeam.Add("Bye");
}
int numDays = (numTeams - 1);
int halfSize = numTeams / 2;
List<string> teams = new List<string>();
teams.AddRange(ListTeam.Skip(halfSize).Take(halfSize));
teams.AddRange(ListTeam.Skip(1).Take(halfSize -1).ToArray().Reverse());
int teamsSize = teams.Count;
for (int day = 0; day < numDays; day++)
{
Console.WriteLine("Day {0}", (day + 1));
int teamIdx = day % teamsSize;
Console.WriteLine("{0} vs {1}", teams[teamIdx], ListTeam[0]);
for (int idx = 1; idx < halfSize; idx++)
{
int firstTeam = (day + idx) % teamsSize;
int secondTeam = (day + teamsSize - idx) % teamsSize;
Console.WriteLine("{0} vs {1}", teams[firstTeam], teams[secondTeam]);
}
}
```

}

which would print each day’s team matches.

Let me quickly try to explain how the algorithm works:

I noticed that since we are rotating all the teams except the first one, if we put all the teams in an array except the first one, then we should just read off the first team from that array using index offset based on the day and doing modular arithmetic to wrap around correctly. In practice we would be treating that array as infinitely repeating in both directions and we would be sliding our view incrementally to right (or to the left).

There is one snag, however, and that is the fact that we have to order the teams in a very particular way for this to work correctly. Otherwise, we do not get the correct rotation. Because of this we need to read of the matching second team in a very peculiar way as well.

The correct way to prepare your list is as follows:

Never put the first team (Team#1) in the list.

Take the last half of the team list and put them in the front of the list.

Take the first half of the list, reverse it and put them in the list (but not Team#1).

Now, the correct way to read off the list is as follow:

For each day, increment the first index you are looking at by 1.

For the first team that you see at that location, match that team with Team#1.

For the next team in the list ((day + idx) % numDays), we would normally match it with the team that is offset by half the number of teams minus 1 (minus 1 because we dealt with the first match ourselves). However, since the second half of our list was prepared by reverting, we need to match that offset in the reverted second half of the list. A simpler way to do is to observe that in this is equivalent to matching the same index but from the end of the list. Given the current day offset that is (day + (numDays - idx)) % numDays.

You can simply visit this link also for a better understanding along with updates to optimise the algorithm.

}

Can you give a better explanation of what you mean, like an example of what it does.