Question

我正在尝试构建一个Javascript函数作为输入：

玩家阵列，例如["player1","player2","player3","player4"] （可能只有相同数量的玩家）

并根据以下规则为锦标赛设计动态创建数组：

每个玩家与同一玩家合作不超过一次
每位玩家都有相同数量的总比赛

输出将是一个包含匹配数组的数组，每个匹配包含四个条目，例如[player1，player2，player3，player4]代表player1，player2代表player3和player4。

[["player1","player2","player3","player4"], ["player1","player3","player2","player4"], ...]

目前，我使用类似下面的示例进行硬编码，但遗憾的是仅限于预定义数量的播放器。

const m = [];

const A = players[0];
const B = players[1];
const C = players[2];
const D = players[3];
const E = players[4];
const F = players[5];
const G = players[6];
const H = players[7];
const I = players[8];
const J = players[9];
const K = players[10];
const L = players[11];
const M = players[12];
const N = players[13];
const O = players[14];
const P = players[15];

m.push(A, B, C, P);
m.push(A, C, E, O);
m.push(B, C, D, A);
m.push(B, D, F, P);
m.push(C, D, E, B);
m.push(C, E, G, A);
m.push(D, E, F, C);
m.push(D, F, H, B);
m.push(E, F, G, D);
m.push(E, G, I, C);
m.push(F, G, H, E);
m.push(F, H, J, D);
m.push(G, H, I, F);
m.push(G, I, K, E);
m.push(H, I, J, G);
m.push(H, J, L, F);
m.push(I, J, K, H);
m.push(I, K, M, G);
m.push(J, K, L, I);
m.push(J, L, N, H);
m.push(K, L, M, J);
m.push(K, M, O, I);
m.push(L, M, N, K);
m.push(L, N, P, J);
m.push(M, N, O, L);
m.push(M, O, A, K);
m.push(N, O, P, M);
m.push(N, P, B, L);
m.push(O, P, A, N);
m.push(O, A, C, M);
m.push(P, A, B, O);
m.push(P, B, D, N);

return m;

感谢每一个提示！

干杯

Answer 1

您可以采用组合算法，检查所需结果的长度为4。

function getTournament(array, size) {

    function fork(i, t) {
        if (t.length === size) {
            result.push(t);
            return;
        }
        if (i === array.length) {
            return;
        }
        fork(i + 1, t.concat([array[i]]));
        fork(i + 1, t);
    }

    var result = [];
    fork(0, []);
    return result;
}

console.log(getTournament([1, 2, 3, 4, 5, 6], 4).map(function (a) { return JSON.stringify(a); }));

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 2

您可以使用round-robin tournament机制来配对玩家。在每次迭代中，除了一个之外的所有玩家取代下一个玩家。如果玩家的数量是奇数，则将有一个玩家被排除在匹配之外，但在每次迭代中它将是不同的玩家。由于游戏需要2对，因此可能有一对不参与。同样，在每次迭代中，这将是一个不同的对。

此方法将使每个玩家玩其他玩家的游戏数量，除非玩家数量为2模4（即6,10,14 ......）。在这种情况下，除了一个之外的所有玩家将玩相同数量的游戏。这位出色的球员将再打2场比赛。

n 玩家的游戏数量以及每位玩家的游戏数量将遵循以下公式：

#players(n) modulo 4  |   #games             |  #games per player
----------------------+----------------------+--------------------
        0             | n(n-1)/4             |       n-1
        1             | n(n-1)/4             |       n-1
        2             | (n-1)(n-2)/4         |       n-3 (one: n-1)    
        3             | floor((n-1)(n-2)/4)  |       n-3

示例：给定16名玩家，该算法将找到60个游戏，每个玩家可以参加15场比赛。

这是一个实现：

function assignToGames(players) {
    // Round the number of players up to nearest multiple of 2.
    // The potential extra player is a dummy, and the games they play 
    //   will not be included.
    const numPlayers = players.length + players.length % 2, // potential dummy added
        pairsPerRound = numPlayers / 2,
        rotatingPlayers = numPlayers - 1,
        firstRound = players.length % 2, // will make the dummy game being ignored 
        games = [];
    
    for (let round = 0; round < rotatingPlayers; round++) {
        for (let i = firstRound; i < pairsPerRound-1; i+=2) {
            // The following formulas reflect a roundrobin scheme, where
            //   the last player (possibly a dummy) does not move.
            games.push([
                players[i ? (i+round-1) % rotatingPlayers : numPlayers - 1],
                players[(numPlayers-i-2+round) % rotatingPlayers],
                players[(i+round) % rotatingPlayers],
                players[(numPlayers-i-3+round) % rotatingPlayers],
            ]);
        }
    }
    return games;
}

// Optional function to test the correctness of the result, 
//    and count the number of games per player:
function getStatistics(players, games) {
    const usedPairs = new Set(),
        stats = Object.assign(...players.map( player => ({ [player]: 0 }) ));
    
    for (let game of games) {
        // verify uniqueness of pairs
        for (let pairIndex = 0; pairIndex < 4; pairIndex += 2) {
            let pair = JSON.stringify(game.slice(pairIndex,pairIndex+2).sort());
            if (usedPairs.has(pair)) throw "Duplicate pair " + pair;
            usedPairs.add(pair);
        }
    }
    // Count the number of games each player plays:
    for (let i = 0; i < games.length; i++) {
        for (let j = 0; j < 4; j++) {
            stats[games[i][j]]++;
        }
    }
    return stats;
}

// Demo
// Create 16 players. Their values are the letters of the alphabet up to "p". 
const players = Array.from("abcdefghijklmnop");
const games = assignToGames(players);
// Display results
console.log(JSON.stringify(games));
console.log("--- statistics ---");
console.log('#games: ', games.length);
const stats = getStatistics(players, games);
console.log(stats);

Answer 3

存在相当简单的round-robin tournament algorithm

将玩家分为两排。修复第一个玩家位置。写当前对（行之间）。如果玩家数量是奇数，其中一个玩家在每一轮都休息。

对于下一轮轮换球员。再次写对。重复

A B
D C 
-----      pairs A-D, B-C
A D
C B
----
A C
B D

Answer 4

预先知道我正确理解了这个问题，如果您的玩家数量奇数，这就无法解决问题。

注意：每对夫妇只出现一次（意味着如果你在前两个位置有一个和b，或者在第三和第四个位置是唯一的情况，即使可能碰巧在前两个和b中有一个在第3 /第4或反之亦然）
我们有n-1 + n-2 + ... + 2 + 1

n(n-1) / 2

我们希望每场比赛有2对= =＆gt;匹配数量为n(n-1) / 4
一旦我们建立了夫妻（很容易做到），我们想要混合他们;要做到这一点，我们创建一个函数，给出一对夫妇和一对夫妇，返回匹配要求的数组中的第一对（只是不同的ppl）。
请注意，我们已知道匹配的数量，以便我们可以迭代固定的次数。
最后一步，我们希望将情侣合并为4个条目阵列。

这里是代码，

const players = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L'];
let couples = [];
for (let i = 0; i < players.length; i++) {
    for (let j = i + 1; j < players.length; j++) {
        couples.push([players[i], players[j]]);
    }
}
console.log(couples.length === (players.length * (players.length - 1)) / 2); // true

function findFirstAvailableCouple(couple, arr) {
    for (let i = 0; i < arr.length; i++) {
        if (couple.indexOf(arr[i][0]) === -1 && couple.indexOf(arr[i][1]) === -1) {
            const ret = arr.splice(i, 1)[0];
            return ret;
        }
    }
}
let matches = [];
const n = couples.length / 2;
for (let i = 0; i < n; i++) { const current = couples.splice(0, 1)[0];
    matches.push([current, findFirstAvailableCouple(current, couples)]);
}
matches = matches.map(e => [...e[0], ...e[1]]);
console.log(matches);

您可以在控制台上查看结果。

此算法可适用于夫妻/玩家的任意数量的条目（成本增加）

Answer 5

您好，您可以尝试使用以下代码。

function getUniquePairArray(_arr) {
    var _tArr = [];
    for(var i = 0; i < _arr.length; i++) {
        for(var j = i+1; j < _arr.length; j++) {
            _tArr.push([_arr[i],_arr[j]]);
        }   
    } 
    return _tArr;
}

上面的代码将从数组中创建唯一的对。例如输入

[1,2,3,4]

输出

[[1,2]，[1,3]，[1,4]，[2,3]，[2,4]，[3,4]]

var findOne = function (haystack, arr) {
    return arr.some(function (v) {
        return haystack.indexOf(v) >= 0;
    });
};

上面的函数检查给定数组中目标数组中的每个元素。

function finalResult(_arr) {
    var _tArr = [];
    for(var i = 0; i < _arr.length; i++) {
        for(var j = i+1; j < _arr.length; j++) {
            if(!findOne(_arr[i],_arr[j]))
            {
                _tArr.push([_arr[i],_arr[j]]);
                break;
            }
        }   
    } 
    return _tArr;
}

此功能将为您提供所需的输出。

INPUT == finalFun（getUniquePairArray（[“p1”，“p2”，“p3”，“p4”，“p5”]））

OUTPUT =“[p1，p2，p3，p4] [p1，p3，p2，p4] [p1，p4，p2，p3] [p1，p5，p2，p3] [p2，p3，p4，p5 ] [P2，P4，P3，P5] [P2，P5，P3，P4]“

双人锦标赛设计算法

5 个答案: