Question

我正在学习目前在freecodecamp上编码，我的任务是完成一项任务。在这里。

创建一个带有两个或更多数组的函数，并返回所提供数组的对称差异（△或⊕）数组。

给定两组（例如，设置A = {1,2,3}并且设置B = {2,3,4}），   两组的数学术语“对称差异”是一组   两个元素中的任何一个元素，但不是两个元素中的元素（A△B =   C = {1,4}）。对于你所采取的每一个额外的对称差异（比如说   在集合D = {2,3}）上，你应该得到具有元素的集合   在两组中的任何一组中，但不是两组（C△D = {1,4}△{2,3} =   {1,2,3,4}}。

我试过的是连接arguments对象的所有元素。我正在尝试使用本机过滤器方法来过滤掉多次出现的数组中的元素。这是我此刻尝试过的。

function sym() {
  let args = Array.prototype.slice.call(arguments);
  return args.reduce((prev,current) => prev.concat(current),[]) //concat all arguments
              .filter((element, index, array) => array.indexOf(element) !== index);
}

有人可以看看并帮帮我吗？非常感谢！

Answer 1

您可以先过滤a，然后过滤b并结果。

function symetricalDifference(a, b) {
    function isNotInSet(set){
        return function (value) {
            return set.indexOf(value) === -1;
        }
    }

    return a.filter(isNotInSet(b)).concat(b.filter(isNotInSet(a)));
}

console.log(symetricalDifference([1, 2, 3], [2, 3, 4])); // [1, 4]
console.log(symetricalDifference([1, 4], [2, 3]));       // [1, 4, 2, 3]

Answer 2

我认为这个适合你。

function set() {
    let args = Array.prototype.slice.call(arguments);
    return args
        .reduce((prev, next) => prev.concat(next), [])
        .sort((a, b) => a - b)
        .filter( (el, i, array) => {
            if(i === 0) return true;
            if(el !== array[i-1]) {
                if(el !== array[i+1]) return true;
            }
        });
}

逻辑是：首先我们需要将所有数组连接成一个并对其进行排序，以便我们按升序排列整数，如[1,2,2,3,4,5,5]。然后在这个整数列表中，如果某个整数不止一次，那么我们在两个或多个原始数组中都有这个，所以我们需要将它们过滤掉。

结果是：

set([1,2,3], [2,3,4]);
> [1,4]

它适用于两个以上的输入数组，正如您的任务所说：

创建一个需要两个或更多数组的函数......

set([1,2,3], [2,3,4,11], [5,4,8]);
> [1,5,8,11]

虽然，你应该在这里进行类型检查和其他错误处理。

请注意，这仅适用于整数。

对于整数数组的排序，请查看here。

希望这有帮助。

Answer 3

＆＃13;

console.log(sym([1, 2, 3], [5, 2, 1, 4]) )
function sym() {
	var count = {}
	for (var i=0; i<arguments.length; ++i) {
		arguments[i].forEach(function(v){
			if (!count[v]) count[v] = 1
			else ++count[v]
		})
	}
	return Object.keys(count).filter(function(k) {
		return count[k] === 1
	})
}

＆＃13;

Answer 4

我建议

1）使用过滤器和 indexOf 查找重复列表，然后

2）使用过滤器和 sort 返回最终结果如下：



function symmetricalDiff(a, b){
    var common = a.concat(b)
        .filter(function(d, index, inputArray){ 
            return inputArray.indexOf(d) != index
        });
    return (common.length==0) ? a.concat(b).sort() : 
        a.concat(b).filter(function(d){ return !common.includes(d)}).sort();
}
console.log(symmetricalDiff([1,2,3], [2,3,4]));  // [1, 4]
console.log(symmetricalDiff([1,4], [2,3]));       // [1, 4, 2, 3]

有没有办法过滤掉多次出现的数组中的元素？

4 个答案: