Round-robin tournament schedule: Difference between revisions
→{{header|jq}}
m (→{{header|J}}: alternative display of id pairs) |
|||
| (30 intermediate revisions by 15 users not shown) | |||
Line 1:
{{
A round-robin tournament is also known as an all-play-all-tournament; each participant plays every other participant once.
Line 10:
:* '''[[wp:Round-robin tournament|Wikipedia - Round-robin tournament]]'''
<br>
=={{header|Ada}}==
<syntaxhighlight lang="ada">
-- Create a round-robin schedule
-- J. Carter 2023 May
-- Circle method
with Ada.Text_IO;
procedure Round_Robin is
type Player_ID is range 1 .. 12;
type Player_List is array (Player_ID) of Player_ID;
Circle : Player_List;
J : Player_ID;
begin -- Round_Robin
Fill : for I in Circle'Range loop
Circle (I) := I;
end loop Fill;
All_Rounds : for Round in 1 .. Player_ID'Last - 1 loop
Ada.Text_IO.Put_Line (Item => "Round" & Round'Image);
J := Player_ID'Last;
Pairs : for I in 1 .. Player_ID'Last / 2 loop
Order : declare
Min : constant Player_ID := Player_ID'Min (Circle (I), Circle (J) );
Max : constant Player_ID := Player_ID'Max (Circle (I), Circle (J) );
begin -- Order
Ada.Text_IO.Put_Line (Item => Min'Image & " v" & Max'Image);
J := J - 1;
end Order;
end loop Pairs;
Ada.Text_IO.New_Line;
Circle := Circle (Circle'First) & Circle (Circle'Last) & Circle (Circle'First + 1 .. Circle'Last - 1);
end loop All_Rounds;
end Round_Robin;
</syntaxhighlight>
{{out}}
<pre>
Round 1
1 v 12
2 v 11
3 v 10
4 v 9
5 v 8
6 v 7
Round 2
1 v 11
10 v 12
2 v 9
3 v 8
4 v 7
5 v 6
Round 3
1 v 10
9 v 11
8 v 12
2 v 7
3 v 6
4 v 5
Round 4
1 v 9
8 v 10
7 v 11
6 v 12
2 v 5
3 v 4
Round 5
1 v 8
7 v 9
6 v 10
5 v 11
4 v 12
2 v 3
Round 6
1 v 7
6 v 8
5 v 9
4 v 10
3 v 11
2 v 12
Round 7
1 v 6
5 v 7
4 v 8
3 v 9
2 v 10
11 v 12
Round 8
1 v 5
4 v 6
3 v 7
2 v 8
9 v 12
10 v 11
Round 9
1 v 4
3 v 5
2 v 6
7 v 12
8 v 11
9 v 10
Round 10
1 v 3
2 v 4
5 v 12
6 v 11
7 v 10
8 v 9
Round 11
1 v 2
3 v 12
4 v 11
5 v 10
6 v 9
7 v 8
</pre>
=={{header|ALGOL 68}}==
{{Trans|XPL0}}
<syntaxhighlight lang="algol68">
BEGIN # round-robin tournament schedule - translation of XPL0 #
INT n = 12; # number of players (must be even) #
[ 1 : n ]INT player;
FOR i TO n DO player[ i ] := i OD;
FOR round TO n - 1 DO
print( ( whole( round, 0 ), ":" ) );
FOR i TO n OVER 2 DO
print( ( REPR 9, whole( player[ i ], 0 ) ) )
OD;
print( ( newline ) );
FOR i FROM n BY -1 TO ( n OVER 2 ) + 1 DO
print( ( REPR 9, whole( player[ i ], 0 ) ) )
OD;
print( ( newline, newline ) );
INT nth player = player[ n ];
player[ 3 : n ] := player[ 2 : n - 1 ];
player[ 2 ] := nth player
OD
END
</syntaxhighlight>
{{out}}
Same as the XPL0 sample.
=={{header|APL}}==
<syntaxhighlight lang="APL">
∇ SCHEDULER N;R;I
R←(⍳N),(2|N)⍴'-'
I←0 ⋄ N←⍴(R)
L:⎕←'ROUND',I←I+1
⎕←((N÷2)↑R),[0.5]⌽(N÷2)↓R
R←(1↑R),1⌽1↓R
→(I<N-1)/L
∇
</syntaxhighlight>
{{out}}
<pre>
SCHEDULER 4
ROUND 1
1 2
4 3
ROUND 2
1 3
2 4
ROUND 3
1 4
3 2
</pre>
=={{header|AWK}}==
Line 50 ⟶ 233:
arr[2] = tmp
}
}</syntaxhighlight>
{{out}}
<pre>1 is too few participants
2 players
Line 111 ⟶ 292:
round 11: 1 3 4 5 6 7
2 12 11 10 9 8</pre>
=={{header|BASIC}}==
==={{header|BASIC256}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="qbasic">arraybase 1
print "Twelve teams"
call roundrob(12)
print "Nine teams with byes"
call roundrob(9)
end
function nob(n,i,byes)
#helper function to allow byess to be printed intelligently
if n > 9 then pad = " " else pad = ""
if n = i and byes then
return pad + "B"
else
if i < 10 then return pad + string(i) else return
end if
end function
subroutine roundrob(n)
byes = 0
if n mod 2 = 1 then #if there is an odd number of competitors
byes = 1 #make note of this fact
n += 1 #and treat the tournament as having one more competitor
end if
dim schd(n)
for i = 1 to n
schd[i] = i #initial population of the array with numbers 1-n
next i
for r = 1 to n-1
print "Round "; rjust(string(r), 2); ": ";
for i = 1 to n/2 #print the pairings according to the scheme
#1 2 3 4
#5 6 7 8
print "("; nob(n,schd[i],byes); " -"; nob(n,schd[i+n/2],byes); " ) ";
next i
print
#now move positions 2-n around clockwise
temp1 = schd[n/2] #need to track two temporary variables
temp2 = schd[n/2+1]
for i = n/2 to 3 step -1 #top row
schd[i] = schd[i-1]
next i
for i = n/2+1 to n-1 #bottom row
schd[i] = schd[i+1]
next i
schd[n] = temp1 #end ifll in the ones that "jumped" between rows
schd[2] = temp2
next r
end subroutine</syntaxhighlight>
==={{header|FreeBASIC}}===
<syntaxhighlight lang="freebasic">function nob( n as uinteger, i as uinteger, bye as boolean ) as string
'helper function to allow byes to be printed intelligently
Line 232 ⟶ 420:
Round 9: ( 1 - 2) ( 3 - 6) ( 4 - 7) ( 5 - 8) ( B - 9)
</pre>
==={{header|uBasic/4tH}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="ubasic-4th">Print "Twelve teams"
Proc _Roundrob(12)
Print
Print "Nine teams with byes"
Proc _Roundrob(9)
End
_Roundrob
Param (1)
Local (5)
b@ = 0
' if there is an odd number of competitors
If a@ % 2 = 1 Then b@ = 1 : a@ = a@ + 1
' make note of this fact and treat the tournament
For d@ = 1 To a@ ' as having one more competitor
@(d@) = d@ ' initial population of the array with numbers 1-n
Next
For c@ = 1 To a@-1 ' print the pairings according to the scheme
Print Using "Round __: ";c@;
' 1 2 3 4
For d@ = 1 To a@/2 ' 5 6 7 8
Print Show(Iif (a@ = @(d@) * b@, " ( B - ", Str(" (_# - ", @(d@))));
Print Show(Iif (a@ = @(d@+a@/2) * b@, " B) ", Str("_#) ", @(d@+a@/2))));
Next
Print ' now move positions 2-n around clockwise
e@ = @(a@/2) ' need to track two temporary variables
f@ = @(a@/2+1)
' top row
For d@ = a@/2 To 3 Step -1
@(d@) = @(d@-1)
Next
' bottom row
For d@ = a@/2+1 To a@-1
@(d@) = @(d@+1)
Next
@(a@) = e@ ' fill in the ones that "jumped" between rows
@(2) = f@
Next
Return</syntaxhighlight>
==={{header|Yabasic}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="vb">print "Twelve teams"
roundrob(12)
print "Nine teams with byes"
roundrob(9)
end
sub nob$(n,i,byes)
//helper sub to allow byess to be printed intelligently
//dim as string pad
if n > 9 then pad$ = " " else pad$ = "" : fi
if n = i and byes then
return pad$+"B"
else
if i < 10 then return pad$+str$(i) else return str$(i) : fi
fi
end sub
sub roundrob(n)
byes = 0
if mod(n, 2) = 1 then //if there is an odd number of competitors
byes = 1 //make note of this fact
n = n+1 //and treat the tournament as having one more competitor
fi
dim schd(n)
//, r, i, temp1, temp2
for i = 1 to n
schd(i) = i //initial population of the array with numbers 1-n
next i
for r = 1 to n-1
print "Round ", r using "##", ": ";
for i = 1 to n/2 //print the pairings according to the scheme
//1 2 3 4
//5 6 7 8
print "(", nob$(n,schd(i),byes), " -", nob$(n,schd(i+n/2),byes), " ) ";
next i
print
//now move positions 2-n around clockwise
temp1 = schd(n/2)//need to track two temporary variables
temp2 = schd(n/2+1)
for i = n/2 to 3 step -1 //top row
schd(i) = schd(i-1)
next i
for i = n/2+1 to n-1 //bottom row
schd(i) = schd(i+1)
next i
schd(n) = temp1 //fill in the ones that "jumped" between rows
schd(2) = temp2
next r
end sub</syntaxhighlight>
=={{header|C++}}==
<syntaxhighlight lang="c++">
#include <algorithm>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <stdexcept>
#include <vector>
void round_robin(uint32_t team_count) {
if ( team_count < 2 ) {
throw std::invalid_argument("Number of teams must be greater than 2: " + team_count);
}
std::vector<uint32_t> rotating_list(team_count);
std::iota(rotating_list.begin(), rotating_list.end(), 2);
if ( team_count % 2 == 1 ) {
rotating_list.emplace_back(0);
team_count++;
}
for ( uint32_t round = 1; round < team_count; ++round ) {
std::cout << "Round " << std::setw(2) << round << ":";
std::vector<uint32_t> fixed_list(1, 1);
fixed_list.insert(fixed_list.end(), rotating_list.begin(), rotating_list.end());
for ( uint32_t i = 0; i < team_count / 2; ++i ) {
std::cout << " ( " << std::setw(2) << fixed_list[i]
<< " vs " << std::setw(2) << fixed_list[team_count - 1 - i] << " )";
}
std::cout << std::endl;
std::rotate(rotating_list.rbegin(), rotating_list.rbegin() + 1, rotating_list.rend());
}
}
int main() {
std::cout << "Round robin for 12 players:" << std::endl;
round_robin(12);
std::cout << std::endl << std::endl;
std::cout << "Round robin for 5 players, 0 denotes a bye:" << std::endl;
round_robin(5);
}
</syntaxhighlight>
{{ out }}
<pre>
Round robin for 12 players:
Round 1: ( 1 vs 12 ) ( 2 vs 11 ) ( 3 vs 10 ) ( 4 vs 9 ) ( 5 vs 8 ) ( 6 vs 7 )
Round 2: ( 1 vs 11 ) ( 13 vs 10 ) ( 2 vs 9 ) ( 3 vs 8 ) ( 4 vs 7 ) ( 5 vs 6 )
Round 3: ( 1 vs 10 ) ( 12 vs 9 ) ( 13 vs 8 ) ( 2 vs 7 ) ( 3 vs 6 ) ( 4 vs 5 )
Round 4: ( 1 vs 9 ) ( 11 vs 8 ) ( 12 vs 7 ) ( 13 vs 6 ) ( 2 vs 5 ) ( 3 vs 4 )
Round 5: ( 1 vs 8 ) ( 10 vs 7 ) ( 11 vs 6 ) ( 12 vs 5 ) ( 13 vs 4 ) ( 2 vs 3 )
Round 6: ( 1 vs 7 ) ( 9 vs 6 ) ( 10 vs 5 ) ( 11 vs 4 ) ( 12 vs 3 ) ( 13 vs 2 )
Round 7: ( 1 vs 6 ) ( 8 vs 5 ) ( 9 vs 4 ) ( 10 vs 3 ) ( 11 vs 2 ) ( 12 vs 13 )
Round 8: ( 1 vs 5 ) ( 7 vs 4 ) ( 8 vs 3 ) ( 9 vs 2 ) ( 10 vs 13 ) ( 11 vs 12 )
Round 9: ( 1 vs 4 ) ( 6 vs 3 ) ( 7 vs 2 ) ( 8 vs 13 ) ( 9 vs 12 ) ( 10 vs 11 )
Round 10: ( 1 vs 3 ) ( 5 vs 2 ) ( 6 vs 13 ) ( 7 vs 12 ) ( 8 vs 11 ) ( 9 vs 10 )
Round 11: ( 1 vs 2 ) ( 4 vs 13 ) ( 5 vs 12 ) ( 6 vs 11 ) ( 7 vs 10 ) ( 8 vs 9 )
Round robin for 5 players, 0 denotes a bye:
Round 1: ( 1 vs 6 ) ( 2 vs 5 ) ( 3 vs 4 )
Round 2: ( 1 vs 5 ) ( 0 vs 4 ) ( 2 vs 3 )
Round 3: ( 1 vs 4 ) ( 6 vs 3 ) ( 0 vs 2 )
Round 4: ( 1 vs 3 ) ( 5 vs 2 ) ( 6 vs 0 )
Round 5: ( 1 vs 2 ) ( 4 vs 0 ) ( 5 vs 6 )
</pre>
=={{header|C#}}==
{{trans|Java}}
<syntaxhighlight lang="C#">
using System;
using System.Collections.Generic;
using System.Linq;
public class RoundRobinTournamentSchedule
{
public static void Main(string[] args)
{
Console.WriteLine("Round robin for 12 players:");
RoundRobin(12);
Console.WriteLine("\n");
Console.WriteLine("Round robin for 5 players, 0 denotes a bye:");
RoundRobin(5);
}
private static void RoundRobin(int teamCount)
{
if (teamCount < 2)
{
throw new ArgumentException($"Number of teams must be greater than 2: {teamCount}");
}
List<int> rotatingList = Enumerable.Range(2, teamCount - 1).ToList();
if (teamCount % 2 == 1)
{
rotatingList.Add(0);
teamCount += 1;
}
for (int round = 1; round < teamCount; round++)
{
Console.Write($"Round {round,2}:");
List<int> fixedList = new List<int> { 1 };
fixedList.AddRange(rotatingList);
for (int i = 0; i < teamCount / 2; i++)
{
Console.Write($" ( {fixedList[i],2} vs {fixedList[teamCount - 1 - i],2} )");
}
Console.WriteLine();
Rotate(rotatingList, 1);
}
}
private static void Rotate(List<int> list, int rotationCount)
{
int count = list.Count;
if (count == 0) return;
rotationCount %= count;
if (rotationCount < 0)
{
rotationCount += count;
}
list.Reverse();
list.Reverse(0, rotationCount);
list.Reverse(rotationCount, count - rotationCount);
}
}
</syntaxhighlight>
{{out}}
<pre>
Round robin for 12 players:
Round 1: ( 1 vs 12 ) ( 2 vs 11 ) ( 3 vs 10 ) ( 4 vs 9 ) ( 5 vs 8 ) ( 6 vs 7 )
Round 2: ( 1 vs 11 ) ( 12 vs 10 ) ( 2 vs 9 ) ( 3 vs 8 ) ( 4 vs 7 ) ( 5 vs 6 )
Round 3: ( 1 vs 10 ) ( 11 vs 9 ) ( 12 vs 8 ) ( 2 vs 7 ) ( 3 vs 6 ) ( 4 vs 5 )
Round 4: ( 1 vs 9 ) ( 10 vs 8 ) ( 11 vs 7 ) ( 12 vs 6 ) ( 2 vs 5 ) ( 3 vs 4 )
Round 5: ( 1 vs 8 ) ( 9 vs 7 ) ( 10 vs 6 ) ( 11 vs 5 ) ( 12 vs 4 ) ( 2 vs 3 )
Round 6: ( 1 vs 7 ) ( 8 vs 6 ) ( 9 vs 5 ) ( 10 vs 4 ) ( 11 vs 3 ) ( 12 vs 2 )
Round 7: ( 1 vs 6 ) ( 7 vs 5 ) ( 8 vs 4 ) ( 9 vs 3 ) ( 10 vs 2 ) ( 11 vs 12 )
Round 8: ( 1 vs 5 ) ( 6 vs 4 ) ( 7 vs 3 ) ( 8 vs 2 ) ( 9 vs 12 ) ( 10 vs 11 )
Round 9: ( 1 vs 4 ) ( 5 vs 3 ) ( 6 vs 2 ) ( 7 vs 12 ) ( 8 vs 11 ) ( 9 vs 10 )
Round 10: ( 1 vs 3 ) ( 4 vs 2 ) ( 5 vs 12 ) ( 6 vs 11 ) ( 7 vs 10 ) ( 8 vs 9 )
Round 11: ( 1 vs 2 ) ( 3 vs 12 ) ( 4 vs 11 ) ( 5 vs 10 ) ( 6 vs 9 ) ( 7 vs 8 )
Round robin for 5 players, 0 denotes a bye:
Round 1: ( 1 vs 0 ) ( 2 vs 5 ) ( 3 vs 4 )
Round 2: ( 1 vs 5 ) ( 0 vs 4 ) ( 2 vs 3 )
Round 3: ( 1 vs 4 ) ( 5 vs 3 ) ( 0 vs 2 )
Round 4: ( 1 vs 3 ) ( 4 vs 2 ) ( 5 vs 0 )
Round 5: ( 1 vs 2 ) ( 3 vs 0 ) ( 4 vs 5 )
</pre>
=={{header|D}}==
<syntaxhighlight lang="go">
import std.stdio;
import std.range;
import std.array;
import std.conv;
import std.algorithm;
void main() {
12.generatePlayers.generateSchedule.displaySchedule;
}
string[] generatePlayers(int n) {
("\nRound-Robin for "~(n).text~" players:\n").writeln;
//
return (n%2 == 0) ? iota(1, n+1).map!(a => a.text).array : iota(1, n+1).map!(a => a.text).array~"bye";
}
string[] mutate(string[] arr) {
return arr[0]~arr[$-1]~ arr[1..$-1].array;
}
string[][] generateSchedule(string[] players) {
auto nbPlayer = players.length;
string[][]schedule;
schedule ~= players;
for(int i = 1; i <= nbPlayer-2; i++)
{
schedule ~= schedule[$-1].mutate;
}
//
return schedule;
}
void displaySchedule(string[][] schedule) {
auto nbPlayer = schedule[0].length;
foreach(i, row; schedule.array)
{
writef("Round %2s: ", i+1);
for(int k=0; k<nbPlayer/2; k++)
{
writef("(%2s vs %2s)", row[k], row[nbPlayer-(k+1)]);
if (k==(nbPlayer/2)-1) writeln; else " ".write;
}
}
//
writeln;
}
</syntaxhighlight>
{{out}}
<pre>
Round-Robin for 12 players:
Round 1: ( 1 vs 12) ( 2 vs 11) ( 3 vs 10) ( 4 vs 9) ( 5 vs 8) ( 6 vs 7)
Round 2: ( 1 vs 11) (12 vs 10) ( 2 vs 9) ( 3 vs 8) ( 4 vs 7) ( 5 vs 6)
Round 3: ( 1 vs 10) (11 vs 9) (12 vs 8) ( 2 vs 7) ( 3 vs 6) ( 4 vs 5)
Round 4: ( 1 vs 9) (10 vs 8) (11 vs 7) (12 vs 6) ( 2 vs 5) ( 3 vs 4)
Round 5: ( 1 vs 8) ( 9 vs 7) (10 vs 6) (11 vs 5) (12 vs 4) ( 2 vs 3)
Round 6: ( 1 vs 7) ( 8 vs 6) ( 9 vs 5) (10 vs 4) (11 vs 3) (12 vs 2)
Round 7: ( 1 vs 6) ( 7 vs 5) ( 8 vs 4) ( 9 vs 3) (10 vs 2) (11 vs 12)
Round 8: ( 1 vs 5) ( 6 vs 4) ( 7 vs 3) ( 8 vs 2) ( 9 vs 12) (10 vs 11)
Round 9: ( 1 vs 4) ( 5 vs 3) ( 6 vs 2) ( 7 vs 12) ( 8 vs 11) ( 9 vs 10)
Round 10: ( 1 vs 3) ( 4 vs 2) ( 5 vs 12) ( 6 vs 11) ( 7 vs 10) ( 8 vs 9)
Round 11: ( 1 vs 2) ( 3 vs 12) ( 4 vs 11) ( 5 vs 10) ( 6 vs 9) ( 7 vs 8)
</pre>
=={{header|EasyLang}}==
{{trans|AWK}}
<syntaxhighlight>
proc roundrobin n . .
numfmt 0 2
print n & " players"
for i to n
arr[] &= i
.
if n mod 2 = 1
n += 1
arr[] &= 0
.
for i = 1 to n - 1
print ""
write "round " & i & ": "
for j = 1 to n / 2
write arr[j] & " "
.
print ""
write " "
for j = n downto n / 2 + 1
write arr[j] & " "
.
print ""
h = arr[n]
for j = n downto 3
arr[j] = arr[j - 1]
.
arr[2] = h
.
.
roundrobin 12
</syntaxhighlight>
=={{header|Go}}==
Line 325 ⟶ 876:
1:11 12:10 2:9 3:8 4:7 5:6
</syntaxhighlight>
=={{header|Java}}==
<syntaxhighlight lang="java">
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public final class RoundRobinTournamentSchedule {
public static void main(String[] args) {
System.out.println("Round robin for 12 players:");
roundRobin(12);
System.out.println(System.lineSeparator());
System.out.println("Round robin for 5 players, 0 denotes a bye:");
roundRobin(5);
}
private static void roundRobin(int teamCount) {
if ( teamCount < 2 ) {
throw new IllegalArgumentException("Number of teams must be greater than 2: " + teamCount);
}
List<Integer> rotatingList = IntStream.rangeClosed(2, teamCount).boxed().collect(Collectors.toList());
if ( teamCount % 2 == 1 ) {
rotatingList.add(0);
teamCount += 1;
}
for ( int round = 1; round < teamCount; round++ ) {
System.out.print(String.format("%s%2d%s", "Round ", round, ":"));
List<Integer> fixedList = IntStream.rangeClosed(1, 1).boxed().collect(Collectors.toList());
fixedList.addAll(rotatingList);
for ( int i = 0; i < teamCount / 2; i++ ) {
System.out.print(String.format("%s%2d%s%2d%s",
" ( ", fixedList.get(i), " vs ", fixedList.get(teamCount - 1 - i), " )"));
}
System.out.println();
Collections.rotate(rotatingList, +1);
}
}
}
</syntaxhighlight>
{{ out }}
<pre>
Round robin for 12 players:
Round 1: ( 1 vs 12 ) ( 2 vs 11 ) ( 3 vs 10 ) ( 4 vs 9 ) ( 5 vs 8 ) ( 6 vs 7 )
Round 2: ( 1 vs 11 ) ( 12 vs 10 ) ( 2 vs 9 ) ( 3 vs 8 ) ( 4 vs 7 ) ( 5 vs 6 )
Round 3: ( 1 vs 10 ) ( 11 vs 9 ) ( 12 vs 8 ) ( 2 vs 7 ) ( 3 vs 6 ) ( 4 vs 5 )
Round 4: ( 1 vs 9 ) ( 10 vs 8 ) ( 11 vs 7 ) ( 12 vs 6 ) ( 2 vs 5 ) ( 3 vs 4 )
Round 5: ( 1 vs 8 ) ( 9 vs 7 ) ( 10 vs 6 ) ( 11 vs 5 ) ( 12 vs 4 ) ( 2 vs 3 )
Round 6: ( 1 vs 7 ) ( 8 vs 6 ) ( 9 vs 5 ) ( 10 vs 4 ) ( 11 vs 3 ) ( 12 vs 2 )
Round 7: ( 1 vs 6 ) ( 7 vs 5 ) ( 8 vs 4 ) ( 9 vs 3 ) ( 10 vs 2 ) ( 11 vs 12 )
Round 8: ( 1 vs 5 ) ( 6 vs 4 ) ( 7 vs 3 ) ( 8 vs 2 ) ( 9 vs 12 ) ( 10 vs 11 )
Round 9: ( 1 vs 4 ) ( 5 vs 3 ) ( 6 vs 2 ) ( 7 vs 12 ) ( 8 vs 11 ) ( 9 vs 10 )
Round 10: ( 1 vs 3 ) ( 4 vs 2 ) ( 5 vs 12 ) ( 6 vs 11 ) ( 7 vs 10 ) ( 8 vs 9 )
Round 11: ( 1 vs 2 ) ( 3 vs 12 ) ( 4 vs 11 ) ( 5 vs 10 ) ( 6 vs 9 ) ( 7 vs 8 )
Round robin for 5 players, 0 denotes a bye:
Round 1: ( 1 vs 0 ) ( 2 vs 5 ) ( 3 vs 4 )
Round 2: ( 1 vs 5 ) ( 0 vs 4 ) ( 2 vs 3 )
Round 3: ( 1 vs 4 ) ( 5 vs 3 ) ( 0 vs 2 )
Round 4: ( 1 vs 3 ) ( 4 vs 2 ) ( 5 vs 0 )
Round 5: ( 1 vs 2 ) ( 3 vs 0 ) ( 4 vs 5 )
</pre>
=={{header|jq}}==
{{Works with|jq}}
'''Works with gojq, the Go implementation of jq'''
'''Adapted from [[#Wren|Wren]]'''
<syntaxhighlight lang="jq">
def lpad($len): tostring | ($len - length) as $l | (" " * $l) + .;
def rotate: .[-1:] + .[:-1];
def roundRobin($n):
{$n, lst: [range(2; $n+1)]}
| if $n % 2 == 1
then .lst += [0] # 0 denotes a bye
| .n += 1
end
| foreach range(1; .n) as $r (.;
.emit = "Round \($r|lpad(3)): "
| ([1] + .lst) as $lst2
| reduce range(0; .n/2) as $i (.;
.emit += " (\($lst2[$i]|lpad(2)) vs \($lst2[.n - 1 - $i]|lpad(2)))")
| .lst |= rotate )
| .emit ;
"Round robin for 12 players:",
roundRobin(12),
"\n\nRound robin for 5 players (0 denotes a bye):\n",
roundRobin(5)
</syntaxhighlight>
{{output}}
Essentially the same as for [[#Wren|Wren]].
=={{header|Julia}}==
Line 381 ⟶ 1,032:
Round 6: (Bye - 7) (1 - 6) (2 - 5) (3 - 4)
Round 7: (Bye - 4) (3 - 5) (2 - 6) (1 - 7)
</pre>
=={{header|Nim}}==
<syntaxhighlight lang="Nim">import std/[algorithm, sequtils, strformat]
proc roundRobin(n: Positive) =
assert n >= 2
var n = n
var list1 = toSeq(2..n)
if n mod 2 == 1:
list1.add 0 # 0 denotes a "bye".
inc n
for r in 1..<n:
stdout.write &"Round {r:2}:"
let list2 = 1 & list1
for i in 0..<(n div 2):
stdout.write &" ({list2[i]:>2} vs {list2[n - i - 1]:<2})"
echo()
list1.rotateLeft(-1)
echo "Round robin for 12 players:\n"
roundRobin(12)
echo "\n\nRound robin for 5 players (0 denotes a bye) :\n"
roundRobin(5)
</syntaxhighlight>
{{out}}
<pre>Round robin for 12 players:
Round 1: ( 1 vs 12) ( 2 vs 11) ( 3 vs 10) ( 4 vs 9 ) ( 5 vs 8 ) ( 6 vs 7 )
Round 2: ( 1 vs 11) (12 vs 10) ( 2 vs 9 ) ( 3 vs 8 ) ( 4 vs 7 ) ( 5 vs 6 )
Round 3: ( 1 vs 10) (11 vs 9 ) (12 vs 8 ) ( 2 vs 7 ) ( 3 vs 6 ) ( 4 vs 5 )
Round 4: ( 1 vs 9 ) (10 vs 8 ) (11 vs 7 ) (12 vs 6 ) ( 2 vs 5 ) ( 3 vs 4 )
Round 5: ( 1 vs 8 ) ( 9 vs 7 ) (10 vs 6 ) (11 vs 5 ) (12 vs 4 ) ( 2 vs 3 )
Round 6: ( 1 vs 7 ) ( 8 vs 6 ) ( 9 vs 5 ) (10 vs 4 ) (11 vs 3 ) (12 vs 2 )
Round 7: ( 1 vs 6 ) ( 7 vs 5 ) ( 8 vs 4 ) ( 9 vs 3 ) (10 vs 2 ) (11 vs 12)
Round 8: ( 1 vs 5 ) ( 6 vs 4 ) ( 7 vs 3 ) ( 8 vs 2 ) ( 9 vs 12) (10 vs 11)
Round 9: ( 1 vs 4 ) ( 5 vs 3 ) ( 6 vs 2 ) ( 7 vs 12) ( 8 vs 11) ( 9 vs 10)
Round 10: ( 1 vs 3 ) ( 4 vs 2 ) ( 5 vs 12) ( 6 vs 11) ( 7 vs 10) ( 8 vs 9 )
Round 11: ( 1 vs 2 ) ( 3 vs 12) ( 4 vs 11) ( 5 vs 10) ( 6 vs 9 ) ( 7 vs 8 )
Round robin for 5 players (0 denotes a bye) :
Round 1: ( 1 vs 0 ) ( 2 vs 5 ) ( 3 vs 4 )
Round 2: ( 1 vs 5 ) ( 0 vs 4 ) ( 2 vs 3 )
Round 3: ( 1 vs 4 ) ( 5 vs 3 ) ( 0 vs 2 )
Round 4: ( 1 vs 3 ) ( 4 vs 2 ) ( 5 vs 0 )
Round 5: ( 1 vs 2 ) ( 3 vs 0 ) ( 4 vs 5 )
</pre>
=={{header|Pascal}}==
A console program in Free Pascal. Uses the circle method, but not exactly as in Wikipedia: the fixed player is the dummy, if present, otherwise the last; and the rotation is anticlockwise.
<syntaxhighlight lang="pascal">
program RoundRobin;
(*
Rosetta Code: write list of matches in a round robin tournament.
Command line:
RoundRobin number_of_players
*)
{$mode objfpc}{$H+}
uses SysUtils;
var
nrPlayers, round : integer;
n, m, c, j, k : integer;
a : array of integer;
// Write the matches in a round, formatting nicely
procedure WriteRound();
var
t, u : integer;
begin
Write( 'Round', round:3, ': ');
u := 0;
for t := 0 to m - 2 do begin
Write( '(', a[u]:2); inc(u);
Write( ' v', a[u]:3, ') '); inc(u);
end;
Write( '(', a[u]:2); // u = n - 2
if c > 0 then
WriteLn( ' v', c:3, ')')
else
WriteLn( ' bye)');
end;
begin
if ParamCount < 1 then begin
WriteLn( 'Number of players is required');
exit;
end;
nrPlayers := SysUtils.StrToIntDef( ParamStr(1), -1);
// if string can't be converted, nrPlayers := -1
if (nrPlayers < 2) then begin
WriteLn( 'Invalid number of players');
exit;
end;
WriteLn( 'Round robin with ', nrPlayers, ' players');
m := (nrPlayers + 1) div 2;
n := 2*m;
if Odd( nrPlayers) then c := 0 // dummy player, opponent gets a bye
else c := n; // genuine player
SetLength( a, n);
k := 0;
for j := 0 to m - 2 do begin
a[k] := m - j; inc(k);
a[k] := m + 1 + j; inc(k);
end;
a[k] := 1;
a[n - 1] := c; // a[n - 1] stays = c throughout
round := 1;
WriteRound();
for round := 2 to n - 1 do begin
for j := 0 to n - 2 do begin // increment all entries except a[n - 1]
inc(a[j]);
if a[j] = n then a[j] := 1; // wrap round if necessary
end;
WriteRound();
end;
end.
</syntaxhighlight>
{{out}}
<pre>
Round robin with 12 players
Round 1: ( 6 v 7) ( 5 v 8) ( 4 v 9) ( 3 v 10) ( 2 v 11) ( 1 v 12)
Round 2: ( 7 v 8) ( 6 v 9) ( 5 v 10) ( 4 v 11) ( 3 v 1) ( 2 v 12)
Round 3: ( 8 v 9) ( 7 v 10) ( 6 v 11) ( 5 v 1) ( 4 v 2) ( 3 v 12)
Round 4: ( 9 v 10) ( 8 v 11) ( 7 v 1) ( 6 v 2) ( 5 v 3) ( 4 v 12)
Round 5: (10 v 11) ( 9 v 1) ( 8 v 2) ( 7 v 3) ( 6 v 4) ( 5 v 12)
Round 6: (11 v 1) (10 v 2) ( 9 v 3) ( 8 v 4) ( 7 v 5) ( 6 v 12)
Round 7: ( 1 v 2) (11 v 3) (10 v 4) ( 9 v 5) ( 8 v 6) ( 7 v 12)
Round 8: ( 2 v 3) ( 1 v 4) (11 v 5) (10 v 6) ( 9 v 7) ( 8 v 12)
Round 9: ( 3 v 4) ( 2 v 5) ( 1 v 6) (11 v 7) (10 v 8) ( 9 v 12)
Round 10: ( 4 v 5) ( 3 v 6) ( 2 v 7) ( 1 v 8) (11 v 9) (10 v 12)
Round 11: ( 5 v 6) ( 4 v 7) ( 3 v 8) ( 2 v 9) ( 1 v 10) (11 v 12)
Round robin with 9 players
Round 1: ( 5 v 6) ( 4 v 7) ( 3 v 8) ( 2 v 9) ( 1 bye)
Round 2: ( 6 v 7) ( 5 v 8) ( 4 v 9) ( 3 v 1) ( 2 bye)
Round 3: ( 7 v 8) ( 6 v 9) ( 5 v 1) ( 4 v 2) ( 3 bye)
Round 4: ( 8 v 9) ( 7 v 1) ( 6 v 2) ( 5 v 3) ( 4 bye)
Round 5: ( 9 v 1) ( 8 v 2) ( 7 v 3) ( 6 v 4) ( 5 bye)
Round 6: ( 1 v 2) ( 9 v 3) ( 8 v 4) ( 7 v 5) ( 6 bye)
Round 7: ( 2 v 3) ( 1 v 4) ( 9 v 5) ( 8 v 6) ( 7 bye)
Round 8: ( 3 v 4) ( 2 v 5) ( 1 v 6) ( 9 v 7) ( 8 bye)
Round 9: ( 4 v 5) ( 3 v 6) ( 2 v 7) ( 1 v 8) ( 9 bye)
</pre>
Line 692 ⟶ 1,490:
This seems to be related to the OEIS sequence [https://oeis.org/A036981 "A036981: (2n+1) X (2n+1) symmetric matrices each of whose rows is a permutation of 1..(2n+1)"]. The next term (for N=10) would be 444733651353600 which takes too long to check.
=={{header|Python}}==
===Original method by R. Schurig===
<syntaxhighlight lang="python">
# round_robin.py by Xing216
from copy import deepcopy
def shift_up(myList):
myLen = len(myList)
return [myList[i % myLen] for i in range(1, 1 + myLen)]
def scheduler(competitors):
"""Uses the original method by Richard Schurig"""
if competitors % 2 == 1:
n = competitors + 1
horizontal_rows = n - 1
else:
n = competitors
horizontal_rows = n
vertical_rows = n // 2
table = [[[] for _ in range(vertical_rows)] for _ in range(horizontal_rows)]
competitor = 1
for i, row in enumerate(table):
for col in table[i]:
if competitor == competitors:
col.append(competitor)
competitor = 1
else:
col.append(competitor)
competitor += 1
table2 = deepcopy(table)
table2 = shift_up(table2)
for row in table2: row.reverse()
for i, row in enumerate(table):
for j, col in enumerate(table[i]):
col.append(table2[i][j][0])
return table
def print_table(table):
for i, round in enumerate(table):
print(f"Round {(i + 1):2}", end=": ")
for match in round:
print(f"{match[0]:2}-{match[1]:<2}", end=" ")
print()
print_table(scheduler(12))
</syntaxhighlight>
{{out}}
<pre style="height:10em">
Round 1: 1-12 2-11 3-10 4-9 5-8 6-7
Round 2: 7-6 8-5 9-4 10-3 11-2 12-1
Round 3: 1-12 2-11 3-10 4-9 5-8 6-7
Round 4: 7-6 8-5 9-4 10-3 11-2 12-1
Round 5: 1-12 2-11 3-10 4-9 5-8 6-7
Round 6: 7-6 8-5 9-4 10-3 11-2 12-1
Round 7: 1-12 2-11 3-10 4-9 5-8 6-7
Round 8: 7-6 8-5 9-4 10-3 11-2 12-1
Round 9: 1-12 2-11 3-10 4-9 5-8 6-7
Round 10: 7-6 8-5 9-4 10-3 11-2 12-1
Round 11: 1-12 2-11 3-10 4-9 5-8 6-7
Round 12: 7-6 8-5 9-4 10-3 11-2 12-1
</pre>
===Berger Tables===
<syntaxhighlight lang="python">
# berger_table.py by Xing216
def scheduler(competitors):
if competitors & 1:
competitors += 1
last = competitors
half = competitors // 2
rounds = last - 1
tables = [list() for i in range(rounds)]
for i in range(1, last):
row = i - 1
tables[row] = [list() * half]
tables[row][0] = [0, 0]
if i & 1:
tables[row][0][1] = last
opponent = (i + 1) // 2
tables[row][0][0] = opponent
else:
tables[row][0][0] = last
opponent = half + i // 2
tables[row][0][1] = opponent
for _ in range(1, half):
next_opponent = opponent + 1 if opponent < last - 1 else 1
tables[row].append([next_opponent, 0])
opponent = next_opponent
last_guest = 1
for i in reversed(range(1, last)):
row = i - 1
for j in reversed(range(0, half)):
opponent = last_guest
if j > 0:
tables[row][j][1] = opponent
last_guest = opponent + 1 if opponent < last - 1 else 1
return tables
def print_table(table):
for i, round in enumerate(table):
print(f"Round {(i + 1):2}", end=": ")
for match in round:
print(f"{match[0]:2}-{match[1]:<2}", end=" ")
print()
print_table(scheduler(12))
</syntaxhighlight>
{{out}}
<pre style="height:10em">
Round 1: 1-12 2-11 3-10 4-9 5-8 6-7
Round 2: 12-7 8-6 9-5 10-4 11-3 1-2
Round 3: 2-12 3-1 4-11 5-10 6-9 7-8
Round 4: 12-8 9-7 10-6 11-5 1-4 2-3
Round 5: 3-12 4-2 5-1 6-11 7-10 8-9
Round 6: 12-9 10-8 11-7 1-6 2-5 3-4
Round 7: 4-12 5-3 6-2 7-1 8-11 9-10
Round 8: 12-10 11-9 1-8 2-7 3-6 4-5
Round 9: 5-12 6-4 7-3 8-2 9-1 10-11
Round 10: 12-11 1-10 2-9 3-8 4-7 5-6
Round 11: 6-12 7-5 8-4 9-3 10-2 11-1
</pre>
=={{header|Quackery}}==
<syntaxhighlight lang="Quackery">
[ stack ] is participants ( --> s )
[ dup 10 < if sp echo ] is recho ( n --> )
[ dup participants share
> iff
[ drop say " bye " ]
done
say " vs "
dup echo 10 < if sp ] is lecho ( n --> )
[ dup participants put
dup 1 & +
[] over 1 - times
[ i 1+ join ]
over 1 - times
[ say "Round "
i^ 1+ recho
say ": "
over dip
[ 2dup join ]
times
[ i i^ < iff
conclude done
dup i peek recho
dup i^ peek lecho
say " " ]
drop cr
over 2 / 1+
split swap join ]
2drop participants release ] is schedule ( n --> )
say "12 participants:" cr
12 schedule
cr
say "5 participants:" cr
5 schedule
cr
say "1 participant:" cr
1 schedule
cr
say "0 participants:" cr
0 schedule</syntaxhighlight>
{{out}}
<pre>12 participants:
Round 1: 1 vs 12 2 vs 11 3 vs 10 4 vs 9 5 vs 8 6 vs 7
Round 2: 5 vs 12 6 vs 4 7 vs 3 8 vs 2 9 vs 1 10 vs 11
Round 3: 9 vs 12 10 vs 8 11 vs 7 1 vs 6 2 vs 5 3 vs 4
Round 4: 2 vs 12 3 vs 1 4 vs 11 5 vs 10 6 vs 9 7 vs 8
Round 5: 6 vs 12 7 vs 5 8 vs 4 9 vs 3 10 vs 2 11 vs 1
Round 6: 10 vs 12 11 vs 9 1 vs 8 2 vs 7 3 vs 6 4 vs 5
Round 7: 3 vs 12 4 vs 2 5 vs 1 6 vs 11 7 vs 10 8 vs 9
Round 8: 7 vs 12 8 vs 6 9 vs 5 10 vs 4 11 vs 3 1 vs 2
Round 9: 11 vs 12 1 vs 10 2 vs 9 3 vs 8 4 vs 7 5 vs 6
Round 10: 4 vs 12 5 vs 3 6 vs 2 7 vs 1 8 vs 11 9 vs 10
Round 11: 8 vs 12 9 vs 7 10 vs 6 11 vs 5 1 vs 4 2 vs 3
5 participants:
Round 1: 1 bye 2 vs 5 3 vs 4
Round 2: 2 bye 3 vs 1 4 vs 5
Round 3: 3 bye 4 vs 2 5 vs 1
Round 4: 4 bye 5 vs 3 1 vs 2
Round 5: 5 bye 1 vs 4 2 vs 3
1 participant:
Round 1: 1 bye
0 participants:
</pre>
=={{header|Raku}}==
Line 779 ⟶ 1,766:
1 3 4 5 6 7
2 12 11 10 9 8
</pre>
=={{header|Rust}}==
{{Trans|Nim}}
<syntaxhighlight lang="rust">
fn round_robin(n: usize) {
assert!(n >= 2);
let mut n = n;
let mut list1: Vec<usize> = (2..=n).collect();
if n % 2 == 1 {
list1.push(0); // 0 denotes a "bye".
n += 1;
}
for r in 1..n {
print!("Round {:2}:", r);
let list2 = vec![1].into_iter().chain(list1.iter().cloned()).collect::<Vec<_>>();
for i in 0..(n / 2) {
print!(" ({:>2} vs {:<2})", list2[i], list2[n - i - 1]);
}
println!();
list1.rotate_right(1);
}
}
fn main() {
println!("Round robin for 12 players:\n");
round_robin(12);
println!("\n\nRound robin for 5 players (0 denotes a bye):\n");
round_robin(5);
}
</syntaxhighlight>
{{out}}
<pre>
Round robin for 12 players:
Round 1: ( 1 vs 12) ( 2 vs 11) ( 3 vs 10) ( 4 vs 9 ) ( 5 vs 8 ) ( 6 vs 7 )
Round 2: ( 1 vs 11) (12 vs 10) ( 2 vs 9 ) ( 3 vs 8 ) ( 4 vs 7 ) ( 5 vs 6 )
Round 3: ( 1 vs 10) (11 vs 9 ) (12 vs 8 ) ( 2 vs 7 ) ( 3 vs 6 ) ( 4 vs 5 )
Round 4: ( 1 vs 9 ) (10 vs 8 ) (11 vs 7 ) (12 vs 6 ) ( 2 vs 5 ) ( 3 vs 4 )
Round 5: ( 1 vs 8 ) ( 9 vs 7 ) (10 vs 6 ) (11 vs 5 ) (12 vs 4 ) ( 2 vs 3 )
Round 6: ( 1 vs 7 ) ( 8 vs 6 ) ( 9 vs 5 ) (10 vs 4 ) (11 vs 3 ) (12 vs 2 )
Round 7: ( 1 vs 6 ) ( 7 vs 5 ) ( 8 vs 4 ) ( 9 vs 3 ) (10 vs 2 ) (11 vs 12)
Round 8: ( 1 vs 5 ) ( 6 vs 4 ) ( 7 vs 3 ) ( 8 vs 2 ) ( 9 vs 12) (10 vs 11)
Round 9: ( 1 vs 4 ) ( 5 vs 3 ) ( 6 vs 2 ) ( 7 vs 12) ( 8 vs 11) ( 9 vs 10)
Round 10: ( 1 vs 3 ) ( 4 vs 2 ) ( 5 vs 12) ( 6 vs 11) ( 7 vs 10) ( 8 vs 9 )
Round 11: ( 1 vs 2 ) ( 3 vs 12) ( 4 vs 11) ( 5 vs 10) ( 6 vs 9 ) ( 7 vs 8 )
Round robin for 5 players (0 denotes a bye):
Round 1: ( 1 vs 0 ) ( 2 vs 5 ) ( 3 vs 4 )
Round 2: ( 1 vs 5 ) ( 0 vs 4 ) ( 2 vs 3 )
Round 3: ( 1 vs 4 ) ( 5 vs 3 ) ( 0 vs 2 )
Round 4: ( 1 vs 3 ) ( 4 vs 2 ) ( 5 vs 0 )
Round 5: ( 1 vs 2 ) ( 3 vs 0 ) ( 4 vs 5 )
</pre>
=={{header|Scala}}==
{{trans|Java}}
<syntaxhighlight lang="Scala">
object RoundRobinTournamentSchedule extends App {
def roundRobin(teamCount: Int): Unit = {
require(teamCount >= 2, s"Number of teams must be greater than 2: $teamCount")
var rotatingList = (2 to teamCount).toList
var adjustedTeamCount = teamCount
if (teamCount % 2 == 1) {
rotatingList :+= 0
adjustedTeamCount += 1
}
for (round <- 1 until adjustedTeamCount) {
print(f"Round $round%2d:")
val fixedList = 1 :: rotatingList
for (i <- 0 until adjustedTeamCount / 2) {
print(f" ( ${fixedList(i)}%2d vs ${fixedList(adjustedTeamCount - 1 - i)}%2d )")
}
println()
rotatingList = rotatingList.last :: rotatingList.init
}
}
println("Round robin for 12 players:")
roundRobin(12)
println()
println("Round robin for 5 players, 0 denotes a bye:")
roundRobin(5)
}
</syntaxhighlight>
{{out}}
<pre>
Round robin for 12 players:
Round 1: ( 1 vs 12 ) ( 2 vs 11 ) ( 3 vs 10 ) ( 4 vs 9 ) ( 5 vs 8 ) ( 6 vs 7 )
Round 2: ( 1 vs 11 ) ( 12 vs 10 ) ( 2 vs 9 ) ( 3 vs 8 ) ( 4 vs 7 ) ( 5 vs 6 )
Round 3: ( 1 vs 10 ) ( 11 vs 9 ) ( 12 vs 8 ) ( 2 vs 7 ) ( 3 vs 6 ) ( 4 vs 5 )
Round 4: ( 1 vs 9 ) ( 10 vs 8 ) ( 11 vs 7 ) ( 12 vs 6 ) ( 2 vs 5 ) ( 3 vs 4 )
Round 5: ( 1 vs 8 ) ( 9 vs 7 ) ( 10 vs 6 ) ( 11 vs 5 ) ( 12 vs 4 ) ( 2 vs 3 )
Round 6: ( 1 vs 7 ) ( 8 vs 6 ) ( 9 vs 5 ) ( 10 vs 4 ) ( 11 vs 3 ) ( 12 vs 2 )
Round 7: ( 1 vs 6 ) ( 7 vs 5 ) ( 8 vs 4 ) ( 9 vs 3 ) ( 10 vs 2 ) ( 11 vs 12 )
Round 8: ( 1 vs 5 ) ( 6 vs 4 ) ( 7 vs 3 ) ( 8 vs 2 ) ( 9 vs 12 ) ( 10 vs 11 )
Round 9: ( 1 vs 4 ) ( 5 vs 3 ) ( 6 vs 2 ) ( 7 vs 12 ) ( 8 vs 11 ) ( 9 vs 10 )
Round 10: ( 1 vs 3 ) ( 4 vs 2 ) ( 5 vs 12 ) ( 6 vs 11 ) ( 7 vs 10 ) ( 8 vs 9 )
Round 11: ( 1 vs 2 ) ( 3 vs 12 ) ( 4 vs 11 ) ( 5 vs 10 ) ( 6 vs 9 ) ( 7 vs 8 )
Round robin for 5 players, 0 denotes a bye:
Round 1: ( 1 vs 0 ) ( 2 vs 5 ) ( 3 vs 4 )
Round 2: ( 1 vs 5 ) ( 0 vs 4 ) ( 2 vs 3 )
Round 3: ( 1 vs 4 ) ( 5 vs 3 ) ( 0 vs 2 )
Round 4: ( 1 vs 3 ) ( 4 vs 2 ) ( 5 vs 0 )
Round 5: ( 1 vs 2 ) ( 3 vs 0 ) ( 4 vs 5 )
</pre>
=={{header|Swift}}==
{{trans|Java}}
<syntaxhighlight lang="Swift">
import Foundation
func roundRobin(teamCount: Int) {
if teamCount < 2 {
fatalError("Number of teams must be greater than 2: \(teamCount)")
}
var rotatingList = Array(2...teamCount)
var effectiveTeamCount = teamCount
if teamCount % 2 == 1 {
rotatingList.append(0) // Adding a 'bye' in case of odd number of teams
effectiveTeamCount += 1
}
for round in 1..<effectiveTeamCount {
print("Round \(round):", terminator: "")
let fixedList = [1] + rotatingList
for i in 0..<(effectiveTeamCount / 2) {
print(" (\(fixedList[i]) vs \(fixedList[effectiveTeamCount - 1 - i]))", terminator: "")
}
print()
rotatingList.rotate(shift: 1)
}
}
extension Array {
mutating func rotate(shift: Int) {
let index = shift >= 0 ?
self.index(self.startIndex, offsetBy: self.count - shift, limitedBy: self.endIndex) :
self.index(self.startIndex, offsetBy: -shift, limitedBy: self.endIndex)
guard let validIndex = index else { return }
self = Array(self[validIndex..<self.endIndex] + self[self.startIndex..<validIndex])
}
}
// Example usage
print("Round robin for 12 players:")
roundRobin(teamCount: 12)
print("\nRound robin for 5 players, 0 denotes a bye:")
roundRobin(teamCount: 5)
</syntaxhighlight>
{{out}}
<pre>
Round robin for 12 players:
Round 1: (1 vs 12) (2 vs 11) (3 vs 10) (4 vs 9) (5 vs 8) (6 vs 7)
Round 2: (1 vs 11) (12 vs 10) (2 vs 9) (3 vs 8) (4 vs 7) (5 vs 6)
Round 3: (1 vs 10) (11 vs 9) (12 vs 8) (2 vs 7) (3 vs 6) (4 vs 5)
Round 4: (1 vs 9) (10 vs 8) (11 vs 7) (12 vs 6) (2 vs 5) (3 vs 4)
Round 5: (1 vs 8) (9 vs 7) (10 vs 6) (11 vs 5) (12 vs 4) (2 vs 3)
Round 6: (1 vs 7) (8 vs 6) (9 vs 5) (10 vs 4) (11 vs 3) (12 vs 2)
Round 7: (1 vs 6) (7 vs 5) (8 vs 4) (9 vs 3) (10 vs 2) (11 vs 12)
Round 8: (1 vs 5) (6 vs 4) (7 vs 3) (8 vs 2) (9 vs 12) (10 vs 11)
Round 9: (1 vs 4) (5 vs 3) (6 vs 2) (7 vs 12) (8 vs 11) (9 vs 10)
Round 10: (1 vs 3) (4 vs 2) (5 vs 12) (6 vs 11) (7 vs 10) (8 vs 9)
Round 11: (1 vs 2) (3 vs 12) (4 vs 11) (5 vs 10) (6 vs 9) (7 vs 8)
Round robin for 5 players, 0 denotes a bye:
Round 1: (1 vs 0) (2 vs 5) (3 vs 4)
Round 2: (1 vs 5) (0 vs 4) (2 vs 3)
Round 3: (1 vs 4) (5 vs 3) (0 vs 2)
Round 4: (1 vs 3) (4 vs 2) (5 vs 0)
Round 5: (1 vs 2) (3 vs 0) (4 vs 5)
</pre>
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<syntaxhighlight lang="
var rotate = Fn.new { |lst|
Line 809 ⟶ 1,989:
roundRobin.call(12)
System.print("\n\nRound robin for 5 players (0 denotes a bye) :\n")
roundRobin.call(5)
</syntaxhighlight>
{{out}}
| |||