Group and Game Algorithm - algorithm

Question

I am thinking of an algorithm that assign games to pairs of opponents which play the game.
I have x opponents and y games (I think y should be x - 1, but I am not sure)
Every opponent should play each game once and if possible play against every opponent once.
What I want is a list of group pairings assigned to a game.
The number of games overall should be minimal.
An example with 4 opponents A, B, C, D and 3 games:
Opp1
Game
Opp2
A
1
B
A
2
C
A
3
D
B
2
C
B
3
D
C
1
D
Here, each opponent plays against another opponent exactly once, and every opponent plays each game exactly once.
Trying that manually for 5 opponents and 4 games already gets complex.
How about 7 opponents and 6 games?
Is that possible at all?
I tried that to solve the problem manually, then I found out that this is too complex.
After that I thought about how I could maybe solve it using an algorithm, but I could not come up with a solution.
I thought maybe a graph algorithm which tries to minimize the overall games count could help.

Answer 1

- LOOP Op1 over groups ( e.g. A,B,C,... )
- LOOP Op2 over groups starting at Op1 + 1 ( e.g B,C, ... )
- LOOP G over games
- IF neither Op1 nor Op2 has played game G
- ASSIGN Op1 v Op2 in game G
- BREAK from LOOP G
Here is the C++ code
#include <string>
#include <fstream>
#include <sstream>
#include <iostream>
#include <vector>
#include <algorithm>
class cMatchMaker
{
public:
void ParseCommand(int argc, char *argv[])
{
if (argc != 3)
exit(1);
groupCount = atoi(argv[1]);
gameCount = atoi(argv[2]);
}
void ConstructGroups()
{
for (int kg = 0; kg < groupCount; kg++)
{
std::string s({'A' + kg});
vGroup.push_back(s);
vGroupHasPlayed.push_back({});
}
}
void ConstructGames()
{
for (int kg = 0; kg < gameCount; kg++)
{
vGame.push_back(std::to_string(kg + 1));
}
}
void MakeMatches()
{
// loop over groups
for (kop1 = 0; kop1 < groupCount; kop1++)
{
// loop over possible opponents
for (kop2 = kop1 + 1; kop2 < groupCount; kop2++)
{
// loop over games
for (auto &game : vGame)
{
// check neither group has played game
if (!HasGameBeenPlayed(
game))
{
// we have a match!
DisplayMatch(
game);
// remember who played what
Remember(
game);
break;
}
}
}
}
}
private:
int groupCount, gameCount;
std::vector<std::string> vGroup, vGame;
std::vector<std::vector<std::string>> vGroupHasPlayed;
int kop1, kop2;
bool HasGameBeenPlayed(
const std::string &game)
{
if (std::find(
vGroupHasPlayed[kop1].begin(),
vGroupHasPlayed[kop1].end(),
game) != vGroupHasPlayed[kop1].end())
return true;
if (std::find(
vGroupHasPlayed[kop2].begin(),
vGroupHasPlayed[kop2].end(),
game) != vGroupHasPlayed[kop2].end())
return true;
return false;
}
void DisplayMatch(
const std::string &game)
{
std::cout << " | " << vGroup[kop1]
<< " | " << game << " | "
<< vGroup[kop2] << " |\n";
}
void Remember(
const std::string &game)
{
vGroupHasPlayed[kop1].push_back(game);
vGroupHasPlayed[kop2].push_back(game);
}
};
main(int argc, char *argv[])
{
cMatchMaker theMatchMaker;
theMatchMaker.ParseCommand(argc, argv);
theMatchMaker.ConstructGroups();
theMatchMaker.ConstructGames();
theMatchMaker.MakeMatches();
return 0;
}
Here is the output for 7 and 6
Op1
Game
Op2
A
1
B
A
2
C
A
3
D
A
4
E
A
5
F
A
6
G
B
3
C
B
2
D
B
5
E
B
4
F
C
1
D
C
6
E
C
4
G
D
6
F
D
5
G
E
1
F
E
2
G
F
3
G