在一组数组中查找唯一项并从找到的数组中删除非唯一项

Question

给定一个对象，其中 Key 作为一个数组（位置），Value 作为一个数组：

// Example Object
0,2 : [6, 8, 9]
0,3 : [1, 6, 8]
0,4 : [6, 8]
0,5 : [6, 8]
0,6 : [4, 5, 8, 9]
0,7 : [5, 8]
0,8 : [4, 5, 7, 9]

（它是这样创建的：

x = {};
x[[0,2]] = [6, 8, 9];
x[[0,3]] = [1, 6, 8];
...

现在，我想将我的对象缩小到这个范围，通过检查数组中的任何数字是否只出现在这个数组中，而不是在其他值的数组中，然后消除里面的所有其他数字保存唯一编号的特定数组。
（规则：给定数组内没有重复，因此无需检查）：

// Result Object
0,2 : [6, 8, 9]
0,3 : [1]
0,4 : [6, 8]
0,5 : [6, 8]
0,6 : [4, 5, 8, 9]  // now 4 becomes also a "loner"
0,7 : [5, 8]
0,8 : [7]

所以这里在 Key [0,3] 中，Value 的数组被缩小到只有 [1]，因为 1 是一个唯一的数字，不会出现在另一个数组中。

我无法为此考虑一个有效的模式......

Answer 1

不明白为什么 0,4 是 [6, 8]。 6 和 8 都已经出现在 0,2 : [6, 8, 9] 中。

u = [];
$.each(x, function(i, arr){
    //console.log(arr);
    x[i] = $.grep(arr, function(elem, i){
        return ($.inArray(elem, u) == -1);
    });
    $.merge(u, arr);
});

Demo

对象 x 被修改为

0,2: [6, 8, 9]
0,3：1
0,4: []
0,5：[]
0,6: [4, 5]
0,7: []
0,8: [7]

$.each(x, function(i, arr){
    u = [];
    $.each(x, function(j, arrJ){
        $.merge(u, i == j ? [] : arrJ);
    });

    var ue = null;
    $.each(arr, function(i, elem){
        if ($.inArray(elem, u) == -1) {
            ue = elem;
        }
    });

    if (ue != null){
        arr.length = 0;
        arr[0] = ue;
    }
});

Demo

Answer 2

这个想法是使用桶， 认为这是一个有趣的实验，我知道代码可以优化，而且不是那么漂亮，但它解决了问题，而且效率并不低：

var x = {};  // object

x[[0,2]] = [6, 8, 9];
x[[0,3]] = [1, 6, 8];
x[[0,4]] = [6, 8];
x[[0,5]] = [6, 8];
x[[0,6]] = [4, 5, 8, 9];
x[[0,7]] = [5, 8];
x[[0,8]] = [4, 5, 7, 9];

var trackCount = [];

for(var key in x){
  for(var j in x[key]){
     // console.log(key);
          if(typeof(trackCount[x[key][j]]) === "undefined"){
       trackCount[x[key][j]] = [];
      }
     // trackCount[x[key][j]].push(trackCount[x[key]]);
       trackCount[x[key][j]].push(key);
  }
}
//console.log(trackCount)
for(var i=0;i<trackCount.length;++i){
   if(trackCount[i] && trackCount[i].length == 1){
     x[trackCount[i][0]] = [];
     x[trackCount[i][0]].push(i)
   }
}
console.log(x);

Answer 3

长篇大论 (jsfiddle)

var sudoku    =  { '0,2' : [6,8,9]
                 , '0,3' : [1,6,8]
                 , '0,4' : [6,8]
                 , '0,5' : [6,8]
                 , '0,6' : [4,5,8,9]
                 , '0,7' : [5,8]
                 , '0,8' : [4,5,7,9]
                 };

var finished  =  false;

while (!finished) {
    var unique  =  {};
    finished    =  true;

    // Build Unique Numbers List
    for (var section in sudoku)
        for (var pos = sudoku[section].length; pos--; ){
            if (typeof unique[ sudoku[section][pos] ] === "undefined")
                unique[ sudoku[section][pos] ] = [];

            unique[sudoku[section][pos]].push(section);
        }    

    // Clean Up Unique Numbers List
    for (var num in unique)
        if (unique[num].length > 1)
            delete unique[num];

    // Remove non-Uniques
    var is_unique = false;
    for ( var num in unique )
        for ( var pos = sudoku[ unique[num] ].length; pos--; ){
            is_unique = false;
            for (var unique_value in unique)
                if (sudoku[ unique[num] ][pos] == unique_value){
                    is_unique = true;
                    break;
                }

            if (!is_unique){
                sudoku[ unique[num] ].splice(pos,1);
                finished = false;
            }
        }
}

console.clear();
console.dir(unique);
console.dir(sudoku);
/**/

---

结果

{数独}
[0,2] : [9]
[0,3] : [1]
[0,4] : [6, 8]
[0,5] : [6, 8]
[0,6] : [4]
[0,7] : [5]
[0,8] : [7]

---

注意：这不是最优化的算法，但由于这是针对数独的，因此性能不会真正受到您选择的任何算法的影响。所以，为了简洁，我会选择 amit_g 的 jQuery 解决方案。否则，上述内容在解释和准确性方面都应该做得很好。

编辑：这已被修改为递归过滤结果。

Answer 4

我会创建一个单独的一维数组来跟踪多维数组中的值。

遍历多维数组中的每个值。如果一维数组中不存在该值，则将其添加到一维数组中并保留在多维数组中。如果值 DOES 存在于单维数组中，只需将其从多维数组中移除并移至下一个值。

Answer 5

这里的想法是我遍历每个数组中的每个数字，并对照它进行检查
一个桶（字符串），它包含所有数组中的所有数字，加入。如果桶中当前x[key][i] 的第一个索引与最后一个索引相同，则表示此编号是唯一的，因此它的持有数组被重置为单独保存该编号。

var x = {};  // object

x[[0,0]] = [6, 8, 9];
x[[0,1]] = [1, 6, 8];
x[[0,2]] = [6, 8];
x[[0,3]] = [6, 8];
x[[0,4]] = [4, 5, 8, 9];
x[[0,5]] = [5, 8];
x[[0,6]] = [4, 5, 7, 9];

function findUniquePosibilites(x){
    var bucket = "";
    for(var key in x)
        bucket += x[key].join("");

    for(var key in x)
        for (var i = x[key].length; i--; ){
            var num = x[key][i];
            if( bucket.indexOf(num) ==  bucket.lastIndexOf(num) ){
                x[key] = [num];
                break;
            };
        }
}

findUniquePosibilites(x);
console.dir( x );

/*
0,0 : [6, 8, 9] 
0,1 : [1]
0,2 : [6, 8]
0,3 : [6, 8]    
0,4 : [4, 5, 8, 9]  
0,5 : [5, 8]    
0,6 : [7]
*/