The shortest way to find one unique value when all other values are the same

Question

In this question at Code Review they tried to find the fastest way to return the unique element in an array where all the elements are the same except one. But what is the shortest code that accomplish the same thing?

Goal

Find the unique element in an array and return it.

Rules

• The input array will contain only integer, strictly positive numbers, so you can use 0 as the end of the input if your language needs it.
• The size of the array will be at least 3 and will have a finite size. You can limit the size of the array to any limit your language has.
• Every element in the array will be the same, except for one which will be different.
• You must output the value (not the position) of the unique element in any standard format. You can output leading or trailing spaces or newlines.
• You can take the input array in any accepted format.

Examples

Input                   Output
------------------------------
[ 1, 1, 1, 2, 1, 1 ]      2
[ 3, 5, 5, 5, 5 ]         3
[ 9, 2, 9, 9, 9, 9, 9 ]   2
[ 4, 4, 4, 6 ]            6
[ 5, 8, 8 ]               5
[ 8, 5, 8 ]               5
[ 8, 8, 5 ]               5

Winner

This is code-golf, so may the shortest code for each language win!

Answer 1

JavaScript (61 60 bytes)

My first attempt in this community, so there's room for improvement:
x=>{[a,b,c]=x.filter((e,i)=>x[i-1]!=e);return !c&&x[1]-a?a:b}

x=>{[a,b,c]=x.filter((e,i)=>x[i-1]!=e);return!c&&x[1]-a?a:b}

Try it online!

Explanation:

x.filter((e,i)=>x[i-1]!=e)

The array is filtered to remove any element that is the same as array[index - 1]. These are then unpacked into variables [a,b,c].
The three scenarios are 1) [same, unique, same] 2) [unique, same] 3) [same, unique]

return !c&&x[1]-a?a:b

If c is undefined, i.e. the unique element was on the end of the array - and if 'a' (which is by now either array[0] or array[last element - 1]) is not equal to array[1], then a is the unique element. Otherwise, we have scenario 1 or 3, either way - return 'b'

Answer 2

jq, 11 bytes

.-[sort[1]]

Try it online!

Explanation

.           # The input
 -          # With all occurances of ... removed:
  [sort     #    The sorted input
       [1]] #    's second item

Answer 3

Wolfram Language (Mathematica) 17 29 28 bytes

Code corrected due to comment by @att:

SortBy[Tally[#],Last][[1,1]]&

theorist managed to shave off one byte with this:

Cases[Tally@#,{_,1}][[1,1]]&

Answer 4

Factor, 28 23 bytes

[ histogram keys last ]

Try it online!

Get the last (second) key in the histogram of the input, which will always have the smaller count.

Answer 5

Raku, 25 bytes

{.BagHash.invert.Hash{1}}

Try it online!

Answer 6

Scala, 85 bytes

Try it online!

def f(x:Seq[Int])=x.groupBy(identity).mapValues(_.length).filter(_._2 == 1).keys.head

This Scala code defines a function f that takes a sequence of integers x as input, and returns the unique element in the sequence.

Here's a breakdown of what the function does:

• x.groupBy(identity) groups the elements in the sequence x by their identity (i.e., their value), returning a map where the keys are the distinct values in x, and the values are arrays of elements in x with that value.
• .mapValues(_.length) transforms the values in the map to their length, i.e., the number of elements in x with that value.
• .filter(_._2 == 1) filters the key-value pairs in the map to keep only those where the value (i.e., the count of elements with that value in x) is equal to 1.
• .keys returns the keys (i.e., the distinct values in x) of the filtered map as a set.
• .head returns the first (and only) element of the set, which is the unique element in x.

So the entire function finds the unique element in x by grouping its elements by their value, counting the elements with each value, filtering for the value with count 1, and returning it.

Answer 7

Vyxal 3, 4 bytes

SġⁿL

Try it Online!

Sorts the array, groups by adjacent items and takes the minimum by length

Answer 8

TI-BASIC, 10 9 bytes

min(Ans)max(Ans)/median(Ans

Takes input in Ans.

Answer 9

Perl 5 -p, 30 bytes

s/\d+//;$_=s/\b$&\b//g?$_+0:$&

Try it online!

Perl 5 -a, 31 bytes

//,(1-grep$_==$',@F)||say for@F

Try it online!

Perl 5 -a, 33 bytes

1-(@b="@F"=~/\b$_\b/g)||say for@F

Try it online!

Answer 10

HBL, 10.5 bytes

+(1.)('1.)(<(1.2
)(%.

Try it!

Port of Arnauld's answer.

-3 bytes thanks to @DLosc!

Explanation:

Helper function:

+(1.)('1.)(<(1.2­⁡​‎‎⁡⁠⁡‏⁠⁠⁠‏​⁡⁠⁡‌⁢​‎‎⁡⁠⁢‏⁠‎⁡⁠⁣‏⁠‎⁡⁠⁤‏⁠‎⁡⁠⁢⁡‏‏​⁡⁠⁡‌⁣​‎‎⁡⁠⁢⁢‏⁠‎⁡⁠⁢⁣‏⁠‎⁡⁠⁢⁤‏⁠‎⁡⁠⁣⁡‏⁠‎⁡⁠⁣⁢‏‏​⁡⁠⁡‌⁤​‎‎⁡⁠⁣⁣‏⁠‎⁡⁠⁣⁤‏‏​⁡⁠⁡‌⁢⁡​‎⁠⁠‎⁡⁠⁤⁡‏⁠‎⁡⁠⁤⁢‏⁠‎⁡⁠⁤⁣‏⁠‎⁡⁠⁤⁤‏‏​⁡⁠⁡‌­
+                 # ‎⁡Add:
 (1.)             # ‎⁢The first element of arg1
     ('1.)        # ‎⁣The last element of arg1
          (<      # ‎⁤Negate below:
            (1.2  # ‎⁢⁡The second element of arg1

Main function:

)(%.­⁡​‎‎⁡⁠⁢‏⁠‎⁡⁠⁣‏⁠‎⁡⁠⁤‏‏​⁡⁠⁡‌⁢​‎‎⁡⁠⁡‏‏​⁡⁠⁡‌­
 (%.  # ‎⁡Sort arg1
)     # ‎⁢Call the function above
💎

Created with the help of Luminespire.

Answer 11

Japt -m, 4 bytes

ü l1

Try it

ü       sort and group
  l1    take lenght 1 result

Answer 12

Retina, 24 bytes

N`
L0`^(\d+)(?!¶\1)|\d+$

Try it online!

This works by sorting the input (one number per line) and then outputting the first number if it is different from the second, and otherwise outputting the last number.

The test case code was taken from Neil's Retina answer which uses an arithmetic method to determine the answer after sorting.

Answer 13

Google Sheets, 28

Closing parens already discounted.

• Column A is input.
• B1 - =SORT(A:A)
• B2 - =FILTER(B:B,B:B<>B2)

Excel 2016, 35

• Column A is input.
• B1 - =MAX(A:A)
• B2 - =IF(MODE(A:A)-B1,B1,MIN(A:A))

If the mode is the same as the max, then it's the min, otherwise max.

Answer 14

Burlesque, 8 bytes

psf:<][~

Try it online!

Explanation:

ps       # Parse input string as a block
  f:     # Frequency list - returns block of blocks with format {frequency value}
    <]   # Take the minimum block, in this case calculated based on the first element (frequency)
      [~ # Take the last element (value)
         # Implicitly output

Answer 15

C# 42 Bytes

r.GroupBy(a=>a).First(a=>a.Count()==1).Key

Answer 16

Pyth - 6 bytes

I'm not quite sure why this doesn't return an array.

f!t/QT

Explanation

f!t/QT
f!t/QTQ implicit Q added
f     Q filter on each element T of input for 
   /QT  number of times t appears in input
  t     minus 1
 !      is equal to zero

Answer 17

Postgresql, 51 bytes

SELECT unnest($1::int[])GROUP BY 1HAVING count(*)=1

Takes input as an integer array. Outputs as a row containing the unique value. If there is more than one unique value, it returns all of them in unspecified order.

If the type is specified in the extended query protocol or a function parameter, it can be reduced to 44 bytes

SELECT $1.unnest GROUP BY 1HAVING count(*)=1

Answer 18

[Python 3], 39 bytes

lambda x:x[[*map(x.count, x)].index(1)]

Answer 19

GolfScript, 6 bytes

~$.1=-

Try it online!

~        # Parse the input to an array
 $       # Sort the array
  .1=    # Get the second number in the array, this will always be the repeated number
     -   # Remove all copies of the repeated number

Answer 20

Scala, 28 27 bytes

a=>a.minBy(x=>a.count(x==))

It finds the minimum number in the list according to the number of occurrences in that same list, since the odd one out will only have 1 occurrence.

Try it in Scastie

Answer 21

Pyt, 3 bytes

ĐṀ\

Try it online!

Đ        implicit input (S); duplicate on top of stack
 Ṁ       get median (m) (I never got around to fixing a bug in the mode operator, but they do the same thing here)
  \      take the set difference between S and m; implicit print

Answer 22

Arturo, 33 bytes

$=>[t:tally&|select[k,v]->v=1t\0]

Try it

Answer 23

><> (Fish), 29 bytes

!!vr:r@:&=&$?$n;
 ~>:@$:@=0$.

Try it

Answer 24

Go, 105 bytes

func(N[]int)int{m,o:=make(map[int]int),0
for _,n:=range N{m[n]++}
for k,v:=range m{if v<2{o=k}}
return o}

Attempt This Online!

Answer 25

Java (JDK), 65 bytes

Not the best Java answer, but still really close using a Stream approach.

l->l.stream().reduce(0,(a,b)->l.indexOf(b)!=l.lastIndexOf(b)?a:b)

Try it online!

Answer 26

Labyrinth, 34 bytes

? }:=
? $ :
: } {
} : +;=$!@
${?"=

Try it online!

Examines windows of size 3 until a window with two different numbers is found, and then XORs the three numbers to get the answer.

Given a window of a b c, the test is done by checking if (a^b) + (b^c) is nonzero. It is trivially zero if a == b == c, and we can be sure that it is strictly positive (and therefore nonzero) when a != b (i.e. (a^b) != 0) or b != c (i.e. (b^c) != 0) since all the input values are positive.

Also, a redundant work is saved by keeping an XORed value in the stack across iterations.

Intro:  ??:}${
??   take two numbers from input [a b]
:}   copy 2nd input to aux.stack [a b | b]
$    XOR                         [a^b | b]
{    pull 2nd input back         [a^b b]

Loop:  ?:}$}:=:{+=   [a^b b] -> [b^c c]
?      take next number from input [a^b b c]
:}     backup c                    [a^b b c | c]
$      XOR                         [a^b b^c | c]
}:     move b^c and copy a^b       [a^b a^b | b^c c]
=:{    swap tops, copy, pull       [a^b b^c b^c a^b | c]
+      add; keep going if zero     [a^b b^c a^b+b^c | c]
=      swap tops                   [... b^c c | ...]

End:  ;=$!@  [a^b b^c a^b+b^c | c]
;=    drop and swap tops   [a^b c | ...]
$!@   print a^b^c and halt

Answer 27

Kotlin, 40 24 bytes

{minBy{r->count{r==it}}}

Try it online!

It doesn't seem to have a count function where you can simply pass the lambda parameter.

-16 bytes thanks to Seggan

Answer 28

Scala 3, 28 bytes

l=>l.minBy(x=>l.count(_==x))

Attempt This Online!

Answer 29

YASEPL, 46 32 30 bytes

=a=1'±" "=d¥0,1`1!+=e¥a,1}3,d<

enter in numbers seperated by a space and nothing else (like 4 4 4 6 4 4)

explanation

=a=1'±" "=d¥0,1`1!+=e¥a,1}3,d<           packed
=a                                       declare increment variable "a"
  =1'                                    get user input and set it to "1"
     ±" "                                split "1" by every space
         =d¥0,1                          get the first item from "1"
               `1        }3,d            while e == d...
                 !+                      increment a by one
                   =e¥a,1                get item at "1" index "a" and set it to "e"
                             <           print variable "e" when finished

Answer 30

SmileBASIC 4, 43 bytes

1  RSORT I:IF I[0]-I[1]GOTO@0
2  ?MIN(I)@0?MAX(I)

---

Receives array input through I[]. The first value printed is the answer, other printed values are to be ignored. Works by reverse-sorting the list of integers (from largest to smallest values) and comparing the zeroth and first elements. If their difference is non-zero, then the odd one out is the larger value (MAX(I)); otherwise, the odd one out is the smaller value (MIN(I)).