生成与串的组合排名

Question

我有这样输入：

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

这些都是独立的实体，并且可以在一个时间被传递只有一个阵列。 即生成等级（a）。 （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; 
} 

任何帮助吗？

Answer 1

您可以在数组进行排序，并采取所有组合和计算组合的发生。

function getCombinations(array) { 
 

 
    function fork(i, t) { 
 
     if (i === array.length) { 
 
      t.length && result.push(t); 
 
      return; 
 
     } 
 
     fork(i + 1, t.concat(array[i])); 
 
     fork(i + 1, t); 
 
    } 
 

 
    var result = []; 
 
    fork(0, []); 
 
    return result; 
 
} 
 

 
function addCombination(array, object) { 
 
    getCombinations(array.sort((a, b) => a - b)) 
 
     .forEach(a => object[a.join(', ')] = (object[a.join(', ')] || 0) + 1); 
 
} 
 

 
var a = [23, 45, 21], 
 
    b = [45, 23], 
 
    c = [21, 32], 
 
    d = [23], 
 
    e = [32], 
 
    f = [50, 54], 
 
    result = Object.create(null); 
 

 
addCombination(a, result); 
 
addCombination(b, result); 
 
addCombination(c, result); 
 
addCombination(d, result); 
 
addCombination(e, result); 
 
addCombination(f, result); 
 

 
console.log(result);

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

Answer 2

你可以这样说：

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} 

Answer 3

您可以创建一个函数来获取所有组合，并在另一个函数计算每个组合键。

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] 
 

 
function comb(arr) { 
 
    var result = []; 
 

 
    function repeat(prev, arr) { 
 
    arr.forEach(function(e, i) { 
 
     var key = prev.length ? prev + ', ' + String(e) : String(e); 
 
     result.push(key); 
 
     repeat(key, arr.slice(i + 1)) 
 
    }) 
 
    } 
 

 
    repeat('', arr); 
 
    return result; 
 
} 
 

 
function count(data) { 
 
    return data.reduce(function(r, e) { 
 
    e.sort(); 
 
    comb(e).forEach(a => !r[a] ? r[a] = 1 : r[a] += 1) 
 
    return r; 
 
    }, {}) 
 
} 
 

 
console.log(count(arr))