如何在Javascript中找到我的N个序列的有效序列

我只是想在N个数字序列中找到正确的序列。我说的是假设我们有5台机器，20个作业必须在这些机器中进行。我们的概率是20！这是2432902008176640000个可能的顺序来做正确的事情。根据完成时间，什么是最好的顺序。我们必须找到它。 不幸的是，我有点困惑，如何获得正确和最佳的时间效率序列。 在产生了序列的可能性之后，我被卡住了。我不知道如何获得正确的序列

我的尝试

var howManyMachines = 2;
var Sequenxe = [
    {
        jobId:1,
        timeToFinish:5
    },
    {
        jobId:2,
        timeToFinish:4
    },
    {
        jobId:3,
        timeToFinish:4
    }


];
var machines = Array(howManyMachines).fill().map((m, i) => {
    var Mindex = i;
    if(i == 0){
        Mindex = 1
    }else{
        Mindex = i+1
    }
    return {
        id: i,
        value: 0,
        jobs: [],
        name:"M"+Mindex

    } });
function permutations(items) {
    if (items.length == 1) return [items];
    var combos = [];
    for (var i = 0; i < items.length; i++) {
        var first = items[i], rest = items.slice(0);
        rest.splice(i, 1);
        permutations(rest).forEach(function(combo){
            combo.unshift(first);
            combos.push(combo);
        });
    }
    return combos;
}



const allSequence = permutations(Sequenxe);


console.log(allSequence.length+" Sequence to test")
console.log(machines.length+" Machines Available");



allSequence.forEach(singleSequence => {
    console.log("===>",singleSequence)
   //I don't Know what to do

});

var howManyMachines=2；
var Sequenxe=[
{
jobId:1，
完成时间：5
},
{
jobId:2，
完成时间：4
},
{
jobId:3，
完成时间：4
}
];
var machines=Array（howManyMachines）.fill（）.map（（m，i）=>{
var Mindex=i；
如果（i==0）{
Mindex=1
}否则{
Mindex=i+1
}
返回{
id:我，
值：0，
职位：[]，
名称：“M”+Mindex
} });
函数置换（项）{
如果（items.length==1）返回[项目]；
var组合=[]；
对于（变量i=0；i{
console.log（“=>”，singleSequence）
//我不知道该怎么办
});

我认为获得完美解决方案的唯一方法是检查所有可能性。 如果你关心性能，这应该是一个正确的解决方案，但在大多数情况下，这应该给你一个合理的快速

主要步骤包括：

按时间对作业排序完成、最长到最短

将第一个作业添加到最短的线程

按总执行时间（从最短到最长）对线程进行排序

转到2并重复，直到没有更多作业可用

var机器=2；
变量作业=[{
jobId:1，
完成时间：5
}, {
jobId:2，
完成时间：4
}, {
jobId:3，
完成时间：4
}];
jobs.sort（（a，b）=>b.timeToFinish-a.timeToFinish）；
变量线程=新数组（2）。填充({
职位：[]，
总时间：0
});
while（jobs.length>0）{
threads=threads.map（t=>{
j=jobs.shift（）；
返回j{
乔布斯：t.jobs.concat（j），
总时间：t.totalTime+j.timeToFinish
}：t；
});
排序（（a，b）=>a.totalTime-b.totalTime）；
}
log（JSON.stringify（threads，null，2））

最好根据完成时间来确定

---

提前计划这些大的工作听起来像是一场灾难。我想试试。源代码已打开。

您可以执行以下操作：；它将生成20个随机时间的作业，然后将它们平均分配到5台机器中

功能组任务（作业、机器计数）{
var sum=作业减少（（p，c）=>p+c.time，0），
initial=[…数组（machineCount）].map（sa=>（sa=[]，sa.sum=0，sa））；
console.log（“作业总数：”，jobs.length，“\n”）；
log（“总作业时间：”，总和“\n”）；
console.log（“机器数：”，machineCount，“\n”）；
log（“每台机器的目标总作业时间：”，总和/machineCount，“\n”）；
返回作业。排序（（a，b）=>b.time-a.time）
.reduce（（机器，作业）=>{var机器=机器.reduce（（p，c）=>p.sum（{id:i，time:~~（Math.random（）*10）+1}）），
结果=组任务（作业，5）；
log（“作业：\n”，JSON.stringify（作业））；
log（“每台机器的作业：”，“\n”，JSON.stringify（结果））高效是什么意思？如何确定效率？我真的不明白这是一个遗传算法…我的意思是最低的时间消耗序列是最好的和有效的。它是遗传算法的起点。不是一个真正的起点，你提供的只是输入。这就像说我已经通过提供一个数字数组来提供排序算法的起点。问题是我必须在那台机器中尝试所有可能的序列。但是代码简单对一个序列有用，谢谢你的回答