Introdução

No momento, estou participando de um torneio de xadrez. Eu me inspirei na programação do torneio. No momento, estou em uma competição com outros três jogadores. Isso significa que nós quatro estamos jogando três rodadas. O cronograma é o seguinte:

Round 1: 1-4 3-2
Round 2: 3-4 2-1
Round 3: 1-3 4-2

Isso também é conhecido como Round Robin . Além disso, este é um cronograma válido . Dizemos que um cronograma é válido quando satisfaz as seguintes condições:

• Todo jogador joga uma vez contra outro jogador.
• 1-2significa que o jogador 1tem branco . Todo jogador tem ou ( N / 2 - 0,5 ) ou ( N / 2 + 0,5 ) vezes branco, com N sendo a quantidade de rodadas.

Por exemplo, no exemplo acima, existem 3 rodadas. Então N = 3. Como você pode ver, a quantidade de rodadas é igual à quantidade de jogadores - 1 . Um jogador tem

• N / 2 - 0,5 = 1 vez branco, ou
• N / 2 + 0,5 = 2 vezes branco.

No exemplo acima:

• jogador 1tem 2 vezes branco,
• jogador 2tem 1 vez branco,
• jogador 3tem 2 vezes branco,
• jogador 4tem 1 vez branco.

A tarefa

Dado um número inteiro par > 1 representando a quantidade de jogadores na competição, produza a programação do torneio.

Casos de teste:

Entrada = 4, isso significa N = 3

Input:     Output:
4          1-4 3-2
           3-4 2-1
           1-3 4-2

Entrada = 10, isso significa N = 9

Input:     Output:
10         1-10  2-9  3-8  4-7  5-6
           10-6  7-5  8-4  9-3  1-2
           2-10  3-1  4-9  5-8  6-7
           10-7  8-6  9-5  1-4  2-3
           3-10  4-2  5-1  6-9  7-8
           10-8  9-7  1-6  2-5  3-4
           4-10  5-3  6-2  7-1  8-9
           10-9  1-8  2-7  3-6  4-5
           5-10  6-4  7-3  8-2  9-1

Entrada = 12, isso significa N = 11

Input:     Output:
12         1-14    2-13   3-12   4-11   5-10   6-9    7-8
           14-8    9-7    10-6   11-5   12-4   13-3   1-2
           2-14    3-1    4-13   5-12   6-11   7-10   8-9
           14-9    10-8   11-7   12-6   13-5   1-4    2-3
           3-14    4-2    5-1    6-13   7-12   8-11   9-10
           14-10   11-9   12-8   13-7   1-6    2-5    3-4
           4-14    5-3    6-2    7-1    8-13   9-12   10-11
           14-11   12-10  13-9   1-8    2-7    3-6    4-5
           5-14    6-4    7-3    8-2    9-1    10-13  11-12
           14-12   13-11  1-10   2-9    3-8    4-7    5-6
           6-14    7-5    8-4    9-3    10-2   11-1   12-13
           14-13   1-12   2-11   3-10   4-9    5-8    6-7
           7-14    8-6    9-5    10-4   11-3   12-2   13-1

Obviamente, os espaços em branco extras que usei entre os números são opcionais, mas não necessários. Você pode produzi-lo da forma que quiser, desde que seja legível.

Nota: Os exemplos acima não são apenas as únicas saídas válidas. Certamente existem saídas mais válidas.

Isso é código-golfe , então a submissão com a menor quantidade de bytes ganha!

Python 2, 200 186 bytes

n=input()
t=range(2,n+1)
for k in t:
 s=[1]+t
 c=[[s[x],s[-x-1]] for x in range(n/2)]
 if k%2:c[0].reverse()
 t=t[-1:]+t[:-1]
 print"\t".join(["-".join([str(y) for y in x]) for x in c])

Exemplo de saída:

$ python chess.py
4
1-4     2-3
3-1     4-2
1-2     3-4

$ python chess.py
10
1-10    2-9     3-8     4-7     5-6
9-1     10-8    2-7     3-6     4-5
1-8     9-7     10-6    2-5     3-4
7-1     8-6     9-5     10-4    2-3
1-6     7-5     8-4     9-3     10-2
5-1     6-4     7-3     8-2     9-10
1-4     5-3     6-2     7-10    8-9
3-1     4-2     5-10    6-9     7-8
1-2     3-10    4-9     5-8     6-7

$ python chess.py
14
1-14    2-13    3-12    4-11    5-10    6-9     7-8
13-1    14-12   2-11    3-10    4-9     5-8     6-7
1-12    13-11   14-10   2-9     3-8     4-7     5-6
11-1    12-10   13-9    14-8    2-7     3-6     4-5
1-10    11-9    12-8    13-7    14-6    2-5     3-4
9-1     10-8    11-7    12-6    13-5    14-4    2-3
1-8     9-7     10-6    11-5    12-4    13-3    14-2
7-1     8-6     9-5     10-4    11-3    12-2    13-14
1-6     7-5     8-4     9-3     10-2    11-14   12-13
5-1     6-4     7-3     8-2     9-14    10-13   11-12
1-4     5-3     6-2     7-14    8-13    9-12    10-11
3-1     4-2     5-14    6-13    7-12    8-11    9-10
1-2     3-14    4-13    5-12    6-11    7-10    8-9

Ou 135 bytes , usando uma saída menos bonita (mas ainda legível):

...
print c

O que produz algo como:

$ python chess.py
4
[[1, 4], [2, 3]]
[[3, 1], [4, 2]]
[[1, 2], [3, 4]]