尝试使用Javascript解决对称差异

我想找出一个解决对称问题的办法 使用javascript实现以下功能的区别 目标：

• 接受未指定数量的数组作为参数
• 保留数组中数字的原始顺序
• 不删除单个数组中的重复数字
• 删除跨阵列发生的重复项

所以比如说,， 如果输入为（[1,1,2,6]、[2,3,5]、[2,3,4]）， 解决方案是[1,1,6,5,4]

我正试图解决这一问题，因为这是一个在线考试给我的挑战 编码社区。挑战的确切指示 国家,

创建一个接受两个或多个数组并返回一个数组的函数 所提供阵列的对称性差异

数学术语“对称差”是指 第一组或第二组中的两组，但不同时在两组中

虽然我下面的解决方案找到了 每个阵列都是唯一的，它消除了所有出现的数字 不止一次，而且不遵守数字顺序

我的问题与上一次的问题非常接近。然而，解决方案 不保留数字的原始顺序，也不保留单个数组中出现的唯一数字的重复项

function sym(args){
    var arr = [];
    var result = [];
    var units;
    var index = {};
    for(var i in arguments){
        units = arguments[i];

    for(var j = 0; j < units.length; j++){
         arr.push(units[j]);
        }
    }

    arr.forEach(function(a){
        if(!index[a]){
            index[a] = 0;
        }
            index[a]++;

    });

       for(var l in index){
           if(index[l] === 1){
               result.push(+l);
           }
       }

    return result;
}
symsym([1, 1, 2, 6], [2, 3, 5], [2, 3, 4]); // => Desired answer: [1, 1, 6. 5. 4]

功能符号（args）{
var-arr=[]；
var结果=[]；
var单位；
var指数={}；
for（参数中的变量i）{
单位=参数[i]；
对于（var j=0；j期望的答案：[1,1,6.5.4]

这是一个使用

Set

对象进行快速查找的版本。以下是基本逻辑：

它将每个作为参数传递的数组放入一个单独的Set对象中（以便于快速查找）

然后，它迭代传入的每个数组，并将其与其他集合对象（不是由被迭代的数组生成的对象）进行比较

如果在任何其他集合中都找不到该项，则将其添加到结果中

因此，它从第一个数组

[1,1,2,6]

开始。由于在其他任何一个数组中都找不到

1

，因此前两个

1

值将分别添加到结果中。然后在第二组中找到

2

，因此不会将其添加到结果中。然后在其他两个集合中都找不到

6

，因此将其添加到结果中。对于第二个数组

[2,3,5]

重复相同的过程，其中

2

和

3

在其他集合中找到，但

5

不是这样，因此

5

被添加到结果中。并且，对于最后一个数组，在其他集合中只找到

4

。因此，最终结果是

[1,1,6,5,4]

Set

对象用于方便和性能。可以使用

.indexOf（）

在每个数组中查找它们，或者如果不想依赖Set对象，可以使用普通对象进行自己的Set-like查找。还有一个集合对象的部分多边形填充，在这里可以使用

函数symDiff（）{
变量集=[]，结果=[]；
//将参数复制到数组中
var args=Array.prototype.slice.call（参数，0）；
//将每个数组放入一个集合中以便于查找
参数forEach（函数（arr）{
推送（新集合（arr））；
});
//现在查看每个数组中的哪些元素是唯一的
//例如，不包含在其他集合中
args.forEach（函数（数组、数组索引）{
//迭代数组中的每个项
array.forEach（函数（项）{
var=false；
//迭代每个集合（使用简单的for循环，这样更容易中断）
对于（var setIndex=0；setIndex}

与所有问题一样，最好从编写算法开始：

连接数组的版本，其中每个数组都经过筛选，以包含除当前数组外没有其他数组包含的元素

然后用JS写下来：

function sym() {
  var arrays = [].slice.apply(arguments);

  return [].concat.apply([],               // concatenate
    arrays.map(                            // versions of the arrays
      function(array, i) {                 // where each array
        return array.filter(               // is filtered to contain
          function(elt) {                  // those elements which
            return !arrays.some(           // no array
              function(a, j) {             // 
                return i !== j             // other than the current one
                  && a.indexOf(elt) >= 0   // contains
                ;
              }
            );
          }
        );
      }
    )
  );
}

非注释版本，使用ES6更简洁地编写：

function sym(...arrays) {
  return [].concat(arrays . 
    map((array, i) => array . 
      filter(elt => !arrays . 
        some((a, j) => i !== j && a.indexOf(elt) >= 0))));
}

这是使用高阶函数的JS代码

功能符号（args）{
var输出；
输出=[].slice.apply（参数）.reduce（函数（上一个，当前）{
current.filter（函数（值、索引、self）{//for unique
返回self.indexOf（value）==索引；
}).map（函数（元素）{//数组
var loc=先前的索引（元素）；
a=[loc！=-1？上一个.拼接（loc，1）：上一个.推（元素）]；
});
返回上一个；
}, []);
文件写入（输出）；
返回输出；
}
sym（[1,2,3]，[5,2,1,4]）只需使用或复制lodash代码。
纯javascript解决方案

function diff(arr1, arr2) {
var arr3= [];
  for(var i = 0; i < arr1.length; i++ ){
    var unique = true;
     for(var j=0; j < arr2.length; j++){
          if(arr1[i] == arr2[j]){
               unique = false;
               break;
          }
     }
  if(unique){
    arr3.push(arr1[i]);}
  }
 return arr3;
}

function symDiff(arr1, arr2){
  return diff(arr1,arr2).concat(diff(arr2,arr1));
}

symDiff([1, "calf", 3, "piglet"], [7, "filly"])
//[1, "calf", 3, "piglet", 7, "filly"]

功能差异（arr1、arr2）{
var arr3=[]；
对于（变量i=0；ifunction sym() {
  var args = Array.prototype.slice.call(arguments);
  var almost = args.reduce(function(a,b){
    return b.filter(function(i) {return a.indexOf(i) < 0;})
    .concat(a.filter(function(i){return b.indexOf(i)<0;}));
  });
  return almost.filter(function(el, pos){return almost.indexOf(el) == pos;});
}

sym([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5]);

//Result: [4,5,1]

function sym() {
  var arrays = [].slice.call(arguments);

  function diff(arr1, arr2) {
    var arr = [];

    arr1.forEach(function(v) {
      if ( !~arr2.indexOf(v) && !~arr.indexOf(v) ) {
        arr.push( v );
      }
    });

    arr2.forEach(function(v) {
      if ( !~arr1.indexOf(v) && !~arr.indexOf(v) ) {
        arr.push( v );
      }
    });
    return arr;
  }

  var result = diff(arrays.shift(), arrays.shift());

  while (arrays.length > 0) {
    result = diff(result, arrays.shift());
  }

  return result;
}

function sym() {
  var arrays = [].slice.call(arguments);

  function diff(arr1, arr2) {
    return arr1.filter(function (v) {
      return !~arr2.indexOf(v);
    });
  }

  return arrays.reduce(function (accArr, curArr) { 
    return [].concat( diff(accArr, curArr), diff(curArr, accArr) )
    .filter(function (v, i, self) { return self.indexOf(v) === i; });
  });

}

function sym(...vs){
    var has = {};
    //flatten values
    vs.reduce((a,b)=>a.concat(b)).
        //if element does not exist add it (value==1)
        //or mark it as multiply found value > 1
        forEach(value=>{has[value] = (has[value]||0)+1});
    return Object.keys(has).filter(x=>has[x]==1).map(x=>parseInt(x,10));
}
console.log(sym([1, 2, 3], [5, 2, 1, 4],[5,7], [5]));//[3,4,7])

function sym(arr1, arr2, ...rest) {

  //creating a array which has unique numbers from both the arrays
  const union = [...new Set([...arr1,...arr2])];

  // finding the Symmetric Difference between those two arrays
  const diff = union.filter((num)=> !(arr1.includes(num) && arr2.includes(num)))

  //if there are more than 2 arrays
  if(rest.length){
    // recurrsively call till rest become 0 
    // i.e.  diff of 1,2 will be the first parameter so every recurrsive call will reduce     //  the arrays till diff between all of them are calculated.

    return sym(diff, rest[0], ...rest.slice(1))
  }
  return diff
}

let a=[1, 1, 2, 6]
let b=[2, 3, 5];
let c= [2, 3, 4]

let result=[...a,...b].filter(item=>!(a.includes(item) && b.includes(item) ))
result=[...result,...c].filter(item=>!(b.includes(item) && c.includes(item) ))

console.log(result)  //[1, 1, 6, 5, 4]