Xjyuk

https://www.codewars.com/kata/find-the-stray-number/train/javascript

I solved this challenge by sorting from least to greatest, and checking if the first element in the array matched the second element in the array.

If the first element does not match, then the different element is the first element.

If the first element does match, then the different element is the last element.

function stray(numbers) 
 numbers = numbers.sort((a, b) => a - b);
 if (numbers[0] !== numbers[1]) 
 return numbers[0];
 
 else 
 return numbers[numbers.length - 1];
 

console.log([17, 17, 3, 17, 17, 17, 17]);

I'm wondering if / how this can be done with the filter() method instead?

You could use the filter method, but I'm not convinced it makes the code any more efficient or readable:

function stray(numbers) 
 return numbers.find(i => numbers.filter(j => j === i).length === 1);

console.log(stray([17, 17, 3, 17, 17, 17, 17]));
console.log(stray([17, 17, 23, 17, 17, 17, 17]));

^{I've added an example where the "stray" number is greater than the others as a sanity check.}

find is a bit like filter except that it returns the first element in the array that causes the function to return true.

filter here is used to find the number which is only found in the array once.

Your original code could be shortened by using a conditional operator, along with the slice function (which shortens the code necessary to get the first/last element a little):

function stray(numbers) 
 numbers = numbers.sort((a, b) => a - b);
 return numbers.slice((numbers[0] !== numbers[1] ? 0 : -1))[0];

console.log(stray([17, 17, 3, 17, 17, 17, 17]));
console.log(stray([17, 17, 23, 17, 17, 17, 17]));

Here is how you could implement it with the filter() method:

const stray = numbers => +numbers.sort((a, b) => a - b)
 .filter((n,i,a) => (i === 0 && a[0] !==a[1]) || (i === a.length-1 && a[a.length-1] !== a[a.length-2]));

console.log(stray([17, 17, 3, 17, 17, 17, 17]));
console.log(stray([2, 2, 2, 2, 2, 14, 2, 2, 2, 2]));

Or in more a clean way:

const stray = numbers => numbers.sort((a, b) => a - b)
 .filter(n => n === numbers[0]).length === 1 ? numbers[0] : numbers[numbers.length-1]

console.log(stray([17, 17, 3, 17, 17, 17, 17]));
console.log(stray([2, 2, 2, 2, 2, 14, 2, 2, 2, 2]));

But as Heretic Monkey said, this is probably not the best approach...

This is a similar idea to the other answers here, but the implementation is a bit different.

First of all, we can assume that the array's length is at least 3, since it needs to have at least two of the same values and one different value.

Let's start by handling the case where the stray value is not in the first element. We could simply write:

a.find(v => v != a[0])

That is, find an element that's different from the first element. But what if the stray element comes first in the array? We can check if the first two elements differ. If they do, then the stray is either in the first or second position, so the third element is not a stray. In this case, we can check against the third element instead of the first; otherwise we check against the first element as before, thus:

a.find(v => a[0] != a[1] ? v != a[2] : v != a[0])

This is a bit code-golfey and not very readable, so I wouldn't recommend it in production, but it may be of some interest as a curiosity.

It may be worth noting that this solution appears to perform quite well, and can be further optimized by doing the inequality check on the first two elements before invoking find, and by using the third parameter to find to access the array, making the callback a pure function and eliminating the need to reference the array via the closed-over variable, for example:

a.find(a[0] != a[1] ?
 (v, i, a) => v != a[2] :
 (v, i, a) => v != a[0])