I am trying to figure out a solution for symmetric

difference using javascript that accomplishes the following

objectives:

- accepts an unspecified number of arrays as arguments
- preserves the original order of the numbers in the arrays
- does not remove duplicates of numbers in single arrays
- removes duplicates occurring across arrays

Thus, for example,

if the input is ([1, 1, 2, 6], [2, 3, 5], [2, 3, 4]),

the solution would be, [1, 1, 6, 5, 4].

I am trying to solve this as challenge given by an online

coding community. The exact instructions of the challenge

state,

Create a function that takes two or more arrays and returns an array

of the symmetric difference of the provided arrays.The mathematical term symmetric difference refers to the elements in

two sets that are in either the first or second set, but not in both.

Although my solution below finds the numbers that are

unique to each array, it eliminates all numbers occuring

more than once and does not keep the order of the numbers.

My question is very close to the one asked at finding symmetric difference/unique elements in multiple arrays in javascript. However, the solution

does not preserve the original order of the numbers and does not preserve duplicates of unique numbers occurring in single arrays.

```
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]
```

## Best Solution

As with all problems, it's best to start off writing an algorithm:

Then just write that down in JS:

Non-commented version, written more succinctly using ES6: