Javascript 使用字符串组合生成排名

我的意见如下：

var a = [23, 45, 21], b = [45, 23], c = [21, 32], d = [23], e= [32], f= [50, 54];

这些都是独立的实体，一次只能传递一个数组。 i、 e发电机（a）。有时以后，GeneratorAnks（b）

结果存储在全局变量中。每次我用输入打电话，结果都会更新

结果应该包括数组中所有值组合的排名

输出应如下所示：

 {
  "21": 2,
  "23": 3,
  "32": 2,
  "45": 2,
  "52": 1,
  "54": 1,
  "23, 45": 2,
  "23, 45, 21": 1,
  "21, 32": 1,
  "50 : 54": 1,
  "50" : 1
}

这就是我所尝试的

var result;
function generateRank(abc) {

 if(!result) {
   result = {};
 }

var spl = getCombinations(abc);    


spl.forEach(function(st, index) {
    var fArrayKey = st.split(":");


    var noMatch = true;

    Object.keys(result).forEach(function(key) {
        console.log(key);
        var matchedKey = containsAllStrings(key, fArrayKey);

        if(matchedKey) {
            console.log("macthed true ");
            result[key] = result[key] + 1;
            noMatch = false;
        }
        else {
            console.log("macthed false ");
            noMatch = true;
        }
    });

    if(noMatch) {
        result[fArrayKey] = 1;
    }


});

}

function containsAllStrings(word, array) {

    for(var k=0; k<array.length; k++) {
        if(word.indexOf(array[k]) == -1) {
           return false;
        }
    }

    return true;

}

function getCombinations(chars) {
  var result = [];
  var f = function(prefix, chars) {
    for (var i = 0; i < chars.length; i++) {
      result.push(prefix + chars[i]);
      f(prefix + chars[i] + ":", chars.slice(i + 1));
    }
  }
  f('', chars);
  return result;
}

var结果；
函数生成器ANK（abc）{
如果（！结果）{
结果={}；
}
var spl=获取组合（abc）；
spl.forEach（函数（st，索引）{
var fArrayKey=st.split（“：”）；
var noMatch=true；
Object.keys（结果）.forEach（函数（键）{
控制台日志（键）；
var matchedKey=containsAllStrings（key，fArrayKey）；
如果（匹配键）{
console.log（“macthed true”）；
结果[键]=结果[键]+1；
noMatch=false；
}
否则{
console.log（“macthed false”）；
noMatch=true；
}
});
if（noMatch）{
结果[fArrayKey]=1；
}
});
}
函数包含字符串（字、数组）{
对于（var k=0；k您可以这样做：

var result = {}

function reduceRanks(ranks) {
  var setId = ranks.join(',')

  if (!result[setId]) result[setId] = 0
  result[setId]++

  ranks.forEach(function(x) {
    if (!result[x]) result[x] = 0
    result[x]++
  })

  return result
}


var ranks = [
  [23, 45, 21],
  [45, 23],
  [21, 32],
  [23],
  [32],
  [50, 54]
]

ranks.forEach(function(rank) {
  reduceRanks(rank)
})
console.log(result)
// {21: 2, 23: 4, 32: 3, 45: 2, 50: 1, 54: 1, 23,45,21: 1, 45,23: 1, 21,32: 1, 50,54: 1}

您可以对数组进行排序，获取所有组合，并计算组合的出现次数


函数组合（数组）{
功能叉（i，t）{
if（i==array.length）{
t、 长度和结果推送（t）；
返回；
}
fork（i+1，t.concat（数组[i]）；
叉（i+1，t）；
}
var结果=[]；
fork（0,[]）；
返回结果；
}
函数addcomposition（数组、对象）{
getCombinations（array.sort（（a，b）=>a-b））
.forEach（a=>object[a.join（'，'）]=（object[a.join（'，'））]| | 0）+1）；
}
变量a=[23,45,21]，
b=[45,23]，
c=[21,32]，
d=[23]，
e=[32]，
f=[50,54]，
结果=Object.create（空）；
添加组合（a，结果）；
添加组合（b，结果）；
添加组合（c，结果）；
添加组合（d，结果）；
添加组合（e，结果）；
addcomposition（f，result）；
console.log（结果）；
.as console wrapper{max height:100%！important；top:0；}
您可以创建一个函数来获取所有组合，并在另一个函数中将每个组合作为键进行计数


var a=[23,45,21]，b=[45,23]，c=[21,32]，d=[23]，e=[32]，f=[50,54]；
var arr=[a，b，c，d，e，f]
功能梳（arr）{
var结果=[]；
功能重复（上一个、下一个）{
arr.forEach（函数（e，i）{
var key=prev.length？prev+'，'+字符串（e）：字符串（e）；
结果：按（键）；
重复（键，arr.slice（i+1））
})
}
重复（“”，arr）；
返回结果；
}
函数计数（数据）{
返回数据.reduce（函数（r，e）{
e、 排序（）；
梳子（e）.forEach（a=>！r[a]？r[a]=1:r[a]+=1）
返回r；
}, {})
}
console.log（计数（arr））