Javascript 随机化团队名称数组并返回n个团队

我花了几个小时努力研究如何创建一个函数，该函数接受一个名称数组并将它们分成n个团队，团队中的所有名称都是随机的

我可以这样做：

var numBig = size of the array % number of teams

var smallTeamSize = Math.floor(size of the array % number of teams)

最大的团队应该比其他团队多出一个名字

因此，首先

numBig

团队将拥有

smallTeamSize+1

名称，其余团队将拥有

smallTeamSize

名称

输入和输出应如下所示：

功能团队（数组，3）

然后函数可能（因为它是随机的）打印出以下内容：

Team 1: jimes, jim, joe
Team 2: jake, rob
Team 3: paps, richie

有什么建议吗

我有一个函数可以将一组名称随机化：

var array = ['jim','jake','jimes','rob','paps','richie','joe'];

function shuffleArray(array) {

    for (var i = array.length - 1; i > 0; i--) {
        var j = Math.floor(Math.random() * i);
        var temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
    return array;
}

var newarray =(shuffleArray(array));

我将如何使用newarray并将其划分为更小的团队？
我写这篇文章的假设是，您希望使用一个名称数组，并从这些名称创建两个团队（尽管您的问题中显然没有明确说明）：

函数createTeams（名称）{
var team1=[]，
N
对于（变量i=0，len=Math.floor（names.length/2）；i


编辑，以包含创建任意数量团队的有点混乱的方法：

function createTeams(names, numTeams) {
    if (!names || typeof names == 'number'){
        return false;
    }
    else {
        numTeams = typeof numTeams == 'undefined' ? 2 : Math.abs(parseInt(numTeams,10));
        var teams = {},
            perTeam = Math.floor(names.length/numTeams),
            n;
        for (var i = 0; i < numTeams; i++){
            teams[i] = [];
        }
        while (names.length - perTeam > 0){
            for (var i = 0; i < numTeams; i++){
                n = Math.floor(Math.random() * names.length);
                if (names.length >= 0 && typeof names[n] !== 'undefined'){
                    teams[i].push(names[n]);
                    names.splice(n,1);
                }
            }
        }
        return teams;
    }
}

var teams = createTeams(['James', 'Bill', 'William', 'Jack', 'Steve'], '5');

console.log(teams);

/*
    {
        '0' : ['Steve'],
        '1' : ['James'],
        '2' : ['Bill'],
        '3' : ['Jack'],
        '4' : ['William']
    }
*/

函数createTeams（名称、numTeams）{
如果（！name | | typeof name=='number'）{
返回false；
}
否则{
numTeams=typeof numTeams=='undefined'？2:Math.abs（parseInt（numTeams，10））；
var团队={}，
perTeam=数学层（名称、长度/numteam），
N
对于（var i=0；i0）{
对于（var i=0；i=0&&typeof name[n]！=='undefined'）{
团队[i].push（名称[n]）；
名称.接头（n，1）；
}
}
}
返回队；
}
}
var teams=createTeams（['James'，'Bill'，'William'，'Jack'，'Steve'，'5'）；
控制台日志（团队）；
/*
{
“0”：[“Steve”]，
“1”：[“詹姆斯”]，
“2”：[“法案”]，
“3”：[“杰克”]，
'4'：['William']
}
*/


参考资料：






您可以将功能拆分团队添加到shuffleArray中

function splitTeams(names) {
    return {'team1': names.splice(0, Math.floor(names.length/2)),
        'team2': names}
}

像这样使用它

var teams = splitTeams(shuffleArray(['jim','jake','jimes','rob','paps','richie']))

要组建多个团队，您可以使用SplitTeam的此变体：

function splitTeams(names, teams_count) {
    var teams = [];
    while (teams_count > 0) {
    teams.push(names.splice(0, Math.floor(names.length/teams_count)))
    teams_count--;
    }
    return teams
}

一旦你有了随机化的阵列，你就可以很容易地将玩家“分配”到你想要的任何数字：

function distributePlayers(names, numberOfTeams) {
    var ret = {};
    var teamCounter = 0;

    for (var i = 0; i < names.length; ++i) {
        if (!ret["array" + teamCounter]) {
            ret["array" + teamCounter] = [];
        }
        ret["array" + teamCounter].push(names[i]);
        if (++teamCounter == numberOfTeams) {
            teamCounter = 0;
        }
    }
    return ret;
}

在
数组内部
将是成员array1、array2。。。阿兰

工作

更新：

要遍历返回，请遍历对象自身的所有属性，并在每个属性中加入数组以获得完整的团队：

for (var property in arrays) {
    // check to make sure you didn't stumble on an inherited property
    if (arrays.hasOwnProperty(property)) {
        var str = property + ": " + arrays[property].join(", ");
        console.log(str);
    }
}            

这将产生以下输出：

array0: richie, jimes, rob
array1: joe, jim
array2: paps, jake

如果要重命名数组以反映团队名称，只需更改
distributePlayers
中
for
循环中的
If
：

if (!ret["Team" + (teamCounter + 1)) {
    ret["Team" + (teamCounter + 1));
}
ret["Team" + (teamCounter + 1)].push(names[i]);

这样，数组名称实际上将反映有用的信息

请参阅此代码，该代码洗牌数组并对其进行切片

var names = ['jim','jake','jimes','rob','paps','richie'];
names.sort(function(){
    return Math.round(Math.random()) - 0.5;
});
var noOfTeams = 3;
var totalTeams = Math.ceil(names.length/noOfTeams);  

var i,j,temparray,chunk = totalTeams;
for (i=0,j=names.length; i<j; i+=chunk) {
    temparray = names.slice(i,i+chunk);
    console.log(temparray);
}

var name=['jim'，'jake'，'jimes'，'rob'，'paps'，'richie']；
names.sort（函数（）{
返回Math.round（Math.random（））-0.5；
});
var-noOfTeams=3；
var totalTeams=Math.ceil（name.length/noOfTeams）；
var i，j，temparray，chunk=totalTeams；
对于（i=0，j=names.length；我将您的任务划分为多个子任务，并分别处理它们。您可以添加输入和有效输出的示例吗？您想传递一个名称数组，并让函数返回两个数组，每队玩家一个数组？抱歉，我刚刚添加了输入和输出的外观。这样可以将我的数组划分为两个团队。如何uld您这样做是为了可以指定需要多少个团队吗？我不确定您的第二个函数是否有效。如果我将9个名称传递给它，其中4个团队作为参数，它将为我提供4个2人团队，其中1人缺失，因此这将返回一个具有多个数组属性的对象，然后返回该对象。我如何使其通过并打印出each数组属性？因此输出看起来像是第1组：jimes、jim、joe
第2组：jake、rob

第3组：paps、richie

if (!ret["Team" + (teamCounter + 1)) {
    ret["Team" + (teamCounter + 1));
}
ret["Team" + (teamCounter + 1)].push(names[i]);

var names = ['jim','jake','jimes','rob','paps','richie'];
names.sort(function(){
    return Math.round(Math.random()) - 0.5;
});
var noOfTeams = 3;
var totalTeams = Math.ceil(names.length/noOfTeams);  

var i,j,temparray,chunk = totalTeams;
for (i=0,j=names.length; i<j; i+=chunk) {
    temparray = names.slice(i,i+chunk);
    console.log(temparray);
}