Round-robin tournament schedule: Difference between revisions

Line 169:

Round 11: 1 vs 12 2 vs 11 3 vs 10 4 vs 9 5 vs 8 6 vs 7

</pre>

=={{header|Phix}}==

Based on the circle with rotor diagrams on the wikipedia page, and implements home/away.

with javascript_semantics

function round_robin(integer n)

--

-- As per the wikipedia page, we do something like this:

--

-- even(n), say 6: in round 1 we have 6 & 1,2,3,4,5 -> {{6,1},{2,5},{3,4}},

-- 2 2,3,4,5,1 -> {{6,2},{3,1},{4,5}},

-- 3 3,4,5,1,2 -> {{6,3},{4,2},{5,1}},

-- 4 4,5,1,2,3 -> {{6,4},{5,3},{1,2}},

-- 5 5,1,2,3,4 -> {{6,5},{1,4},{2,3}}

--

-- for an odd(n), say 5, simply replace all the 6 above with 0 (a bye).

--

-- As per the wikipedia diagram, we pick a rotor (6/0) and arrange the rest

-- in a circle, and as it rotates around the circle we play it against that

-- one then pick off second/last, third/last-but-one, and so forth from the

-- perspective of the rotor. There must obviously be an odd number of teams

-- in the circle itself, otherwise pairing-offs won't meet in the middle.

--

-- However, rather than physically rotate the {1,2,3,4,5}, we'll just say

-- that anything past 5 starts from 1 again (the -= n below), and use the

-- shorthand of l [===length(result)] as our starting position/offset.

--

-- Not shown above, but we'll also use even/odd rules for home/away matches.

--

integer rotor = iff(even(n)?n:0),

l = 0 -- length(result), shorthand

n -= even(n) -- (circle must be odd)

sequence result = {}

for rownd=1 to n do -- (since "round" is a bultin)

sequence games = {iff(even(rownd) or rotor=0?{rownd,rotor}:{rotor,rownd})}

integer opponent = n -- pair rest off from last inwards,

for m=2 to (n+1)/2 do -- such that m plays current opponent

integer rom = m+l, -- all shifted by

rop = opponent+l -- l as an offset

if rom>n then rom -= n end if

if rop>n then rop -= n end if

games &= iff(odd(m)?{{rom,rop}}:{{rop,rom}})

opponent -= 1

end for

result = append(result,games)

l += 1 -- (obviously "l = length(result)" works fine here too)

end for

return result

end function

function vs(sequence pair) -- (display helper)

return sprintf(iff(pair[2]=0?"%2d bye ":"%2d vs %-2d"),pair)

end function

for test=12 to 3 by -9 do

sequence res = round_robin(test)

printf(1,"\nFor %d teams:\n",test)

for r=1 to length(res) do

printf(1,"Round %2d: %s\n",{r,join(apply(res[r],vs))})

end for

<pre>

For 12 teams:

Round 1: 12 vs 1 11 vs 2 3 vs 10 9 vs 4 5 vs 8 7 vs 6

Round 2: 2 vs 12 1 vs 3 4 vs 11 10 vs 5 6 vs 9 8 vs 7

Round 3: 12 vs 3 2 vs 4 5 vs 1 11 vs 6 7 vs 10 9 vs 8

Round 4: 4 vs 12 3 vs 5 6 vs 2 1 vs 7 8 vs 11 10 vs 9

Round 5: 12 vs 5 4 vs 6 7 vs 3 2 vs 8 9 vs 1 11 vs 10

Round 6: 6 vs 12 5 vs 7 8 vs 4 3 vs 9 10 vs 2 1 vs 11

Round 7: 12 vs 7 6 vs 8 9 vs 5 4 vs 10 11 vs 3 2 vs 1

Round 8: 8 vs 12 7 vs 9 10 vs 6 5 vs 11 1 vs 4 3 vs 2

Round 9: 12 vs 9 8 vs 10 11 vs 7 6 vs 1 2 vs 5 4 vs 3

Round 10: 10 vs 12 9 vs 11 1 vs 8 7 vs 2 3 vs 6 5 vs 4

Round 11: 12 vs 11 10 vs 1 2 vs 9 8 vs 3 4 vs 7 6 vs 5

For 3 teams:

Round 1: 1 bye 3 vs 2

Round 2: 2 bye 1 vs 3

Round 3: 3 bye 2 vs 1

</pre>

While I "optimised away" the need for a physical rotate, obviously not because I was concerned with performance but more in the hope of creating shorter and more elegant code, in the end it made little difference.

Should it be more to your taste, you can remove "l" and replace the inner loop above with:

sequence circle = tagset(n)

for rownd=1 to n do -- (since "round" is a bultin)

integer r = circle[1]

sequence games = {iff(even(rownd) or rotor=0?{r,rotor}:{rotor,r})}

integer ldx = 2, rdx = n

while ldx<rdx do

integer teama = circle[ldx],

teamb = circle[rdx]

games &= {iff(odd(ldx)?{teama,teamb},{teamb,teama})}

ldx += 1

rdx -= 1

end while

result = append(result,games)

circle = circle[2..$]&circle[1] -- (physically rotate it)

end for

=={{header|Raku}}==