# Ruby - Finding an Unusual Element for Two Tables

I've been thinking about a following problem - there are two arrays, and I need to find elements not common for them both, for example:

``````a = [1,2,3,4]
b = [1,2,4]
```
```

And the expected answer is `[3]`.

So far I've been doing it like this:

``````a.select { |elem| !b.include?(elem) }
```
```

But it gives me `O(N ** 2)` time complexity. I'm sure it can be done faster ;)

Also, I've been thinking about getting it somehow like this (using some method opposite to `&` which gives common elements of 2 arrays):

``````a !& b  #=> doesn't work of course
```
```

Another way might be to add two arrays and find the unique element with some method similar to `uniq`, so that:

``````[1,1,2,2,3,4,4].some_method #=> would return 3
```
```

The simplest (in terms of using only the arrays already in place and stock array methods, anyway) solution is the union of the differences:

``````a = [1,2,3,4]
b = [1,2,4]
(a-b) | (b-a)
=> [3]
```
```

This may or may not be better than `O(n**2)`. There are other options which are likely to give better peformance (see other answers/comments).

Edit: Here's a quick-ish implementation of the sort-and-iterate approach (this assumes no array has repeated elements; otherwise it will need to be modified depending on what behavior is wanted in that case). If anyone can come up with a shorter way to do it, I'd be interested. The limiting factor is the sort used. I assume Ruby uses some sort of Quicksort, so complexity averages `O(n log n)` with possible worst-case of `O(n**2)`; if the arrays are already sorted, then of course the two calls to `sort` can be removed and it will run in `O(n)`.

``````def diff a, b
a = a.sort
b = b.sort
result = []
bi = 0
ai = 0
while (ai < a.size && bi < b.size)
if a[ai] == b[bi]
ai += 1
bi += 1
elsif a[ai]<b[bi]
result << a[ai]
ai += 1
else
result << b[bi]
bi += 1
end
end
result += a[ai, a.size-ai] if ai<a.size
result += b[bi, b.size-bi] if bi<b.size
result
end
```
```