Non-Unique/Duplicate Elements

Question

Write a program which finds the non-unique elements of an array of signed integers. The resulting array can be in any order.

Your answer may be a snippet which assumes the input to be stored in a variable (d, say) and evaluates to the correct result.

Test Cases

Each test case is a single line in the format input => output. Note that other permutations of the output are valid as well.

[] => [] [-1, 0, 1] => [] [1, 1] => [1] [3, 0, 0, 1, 1, 0, 5, 3] => [3, 0, 1] [-34, 0, 1, -34, 4, 8, 4] => [-34, 4]

Order of the elements doesn't matter.

This is code golf, so the shortest answer (in bytes) wins.

since this is for array of integers code would be different. I think much shorter. That is for a string. — garg10may
– garg10may, Commented Oct 13, 2015 at 10:21
Are we allowed to accept input as lines instead of as an array? For example, instead of [-1, 0, 1], can we input (replace \n with newlines): "-1\n0\n1"? — Addison Crump
– Addison Crump, Commented Oct 13, 2015 at 15:01
Does the output have to be a list or would a set be acceptable? — Dennis
– Dennis, Commented Oct 13, 2015 at 15:06

JohnE · Accepted Answer · 2015-10-13 15:09:00Z

K5, 5 bytes

Assuming the input is already in a variable called d,

?d^?d

Take the distinct elements (?) of d except (d^) the distinct elements of d (?d). Nicely symmetrical, no? This works because the "except" operator removes only the first occurrence of the right argument from the left argument.

More generally,

nu: {?x^?x}

In action:

 nu'(();-1 0 1;1 1;3 0 0 1 1 0 5 3;-34 0 1 -34 4 8 4) (() () ,1 0 1 3 -34 4)

Edit:

If we wanted to preserve the order of the first occurrence of non-unique elements, we could reverse the source list before and after we remove the unique elements via except at the cost of 4 extra bytes:

 nu: {?|(|x)^?x} nu'(();-1 0 1;1 1;3 0 0 1 1 0 5 3;-34 0 1 -34 4 8 4) (() () ,1 3 0 1 -34 4)

Community · Accepted Answer · 2017-04-13 12:39:08Z

CJam, 10

Assuming the array is already in variable D (based on this comment):

D{De=(},_&

Try it online

Explanation:

D{…}, filter items of D based on the block De= count occurrences in D ( decrement (resulting in true/false for duplicate/unique) _& remove duplicates from the results

Note: append a p if you want pretty printing, otherwise the resulting array is just printed out with no delimiters by default. That is acceptable since the question specifies the snippet only needs to "evaluate to the correct result".

Standard input/output version, 13:

q~_{1$e=(},&p

Try it online

Explanation:

q~ read and evaluate the input array _ duplicate the array {…}, filter items based on the block 1$ copy the array e= count occurrences ( decrement (resulting in true/false for duplicate/unique) & set intersection with the initial array (removes duplicates) p pretty print

@Sp3000 I found another 13-byte version before reading your comment :) It preserves the order too. — aditsu quit because SE is EVIL
– aditsu quit because SE is EVIL, Commented Oct 13, 2015 at 10:30

C. Quilley · Accepted Answer · 2015-10-13 11:45:51Z

Haskell - 32

import Data.List;f l=nub$l\\nub l

Pretty short, even with the import. a \\ b removes the first occurrence of each element of b from a, and nub makes all elements of a list unique.

Dennis · Accepted Answer · 2015-10-13 15:23:25Z

Pyth, 7 bytes

S{.-Q{Q

Try it online.

How it works

Pyth automatically stores the evaluated input in Q and prints all unused return values.

 {Q Convert Q into a set. This removes duplicates. .-Q Perform "bagwise" difference of Q and set(Q). This removes the first occurrence of all elements in Q. { Convert to set to deduplicate. S Sort. Returns a list.

Community · Accepted Answer · 2020-06-17 09:04:33Z

8

SQL, 44 42 bytes

SELECT*FROM D GROUP BY I HAVING COUNT(*)>1

I hope it is OK to assume the integers are stored in table D? This will work in both SQLServer, PostgreSQL and possibly others. Thanks to @manatwork from the 2 bytes.

edited Jun 17, 2020 at 9:04

CommunityBot

1

answered Oct 13, 2015 at 18:28

MickyT

12.3k2 gold badges27 silver badges49 bronze badges

\$\begingroup\$ Assuming i is the only field in table d, in PostgreSQL you can reduce it to select*from d group by 1having count(*)>1. (MySQL and SQLite's parser will also handle the unseparated select*from part, but they not understand 1having.) \$\endgroup\$

manatwork
– manatwork

2015-10-14 10:04:45 +00:00
Commented Oct 14, 2015 at 10:04
\$\begingroup\$ @manatwork cheers for that, sql server also understands the select*from. Doesn't like the 1having though.. will leave that as I having \$\endgroup\$

MickyT
– MickyT

2015-10-14 18:25:26 +00:00
Commented Oct 14, 2015 at 18:25

Add a comment |

Adám · Accepted Answer · 2019-01-10 12:58:56Z

APL (Dyalog Unicode), 13 9 bytes^SBCS

Anonymous tacit prefix function.

∊(⊂1↓⊣¨)⌸

Try it online!

(…)⌸ for each unique element (left argument) and the indices where it occurs (right argument), apply the following tacit function:

⊣¨ one of the left (the unique element) for each on the right (the indices)

1↓ drop one

⊂ enclose (prevents padding with zeros to create a non-ragged matrix)

∊ ϵnlist (flatten)

Martin Ender · Accepted Answer · 2015-10-13 11:33:33Z

Mathematica, 29 26 bytes

Assuming that input is stored in d:

Select[d⋃d,d~Count~#>1&]

Otherwise, it's 29 bytes as an unnamed function:

Cases[#⋃#,n_/;#~Count~n>1]&

Here, d⋃d (or #⋃#) is a golfing trick to remove duplicates - by taking the set union with itself, Mathematica interprets the list as a set, removing duplicates automatically, while the actual union doesn't do anything.

Afterwards, both methods simply filter those elements which appear in the original list at least twice.

Cristian Lupascu · Accepted Answer · 2015-10-13 13:47:20Z

6

JavaScript (ES6), 37 bytes

Run this in the JavaScript console:

e={};d.filter(x=>(e[x]=1+e[x]||0)==1)

answered Oct 13, 2015 at 13:47

Cristian Lupascu

8,6892 gold badges26 silver badges52 bronze badges

\$\begingroup\$ It's generally accepted that JavaScript needs some sort of explicit "output/print" function (such as console.log, alert, etc) to be considered complete. If a challenge says "write a program or function", then function returns also suffice. Aside that, very efficient solution! \$\endgroup\$

Mwr247
– Mwr247

2015-10-13 14:08:02 +00:00
Commented Oct 13, 2015 at 14:08
1

\$\begingroup\$ @Mwr247 The question states that the anwer may be a snippet which evaluates to the correct result. \$\endgroup\$

Cristian Lupascu
– Cristian Lupascu

2015-10-13 14:09:52 +00:00
Commented Oct 13, 2015 at 14:09
1

\$\begingroup\$ It seems I misinterpreted that paragraph. Apologies then =) \$\endgroup\$

Mwr247
– Mwr247

2015-10-13 14:12:19 +00:00
Commented Oct 13, 2015 at 14:12
\$\begingroup\$ @Mwr247 No problem! :) \$\endgroup\$

Cristian Lupascu
– Cristian Lupascu

2015-10-13 14:13:18 +00:00
Commented Oct 13, 2015 at 14:13

Add a comment |

Luis Mendo · Accepted Answer · 2015-10-13 16:18:46Z

6

Matlab / Octave, 40

I'm assuming input values are real (not complex). The input is in a variable d.

unique(d(sum(triu(bsxfun(@eq,d,d')))>1))

Try it online in Octave.

edited Oct 13, 2015 at 16:18

answered Oct 13, 2015 at 10:47

Luis Mendo

107k10 gold badges139 silver badges382 bronze badges

\$\begingroup\$ No need to input, you can assume data in variable 'd' \$\endgroup\$

garg10may
– garg10may

2015-10-13 10:49:25 +00:00
Commented Oct 13, 2015 at 10:49
1

\$\begingroup\$ @garg10may Thanks. Updated. You should specify that in your post \$\endgroup\$

Luis Mendo
– Luis Mendo

2015-10-13 10:56:00 +00:00
Commented Oct 13, 2015 at 10:56
\$\begingroup\$ The output is incorrect when d = [3, 0, 0, 1, 1, 0, 5, 3]. There are two 0s. \$\endgroup\$

alephalpha
– alephalpha

2015-10-13 13:23:15 +00:00
Commented Oct 13, 2015 at 13:23
\$\begingroup\$ @alephalpha Thanks! corrected (8 more bytes) \$\endgroup\$

Luis Mendo
– Luis Mendo

2015-10-13 16:19:05 +00:00
Commented Oct 13, 2015 at 16:19
\$\begingroup\$ Shorter: d(sum(triu(bsxfun(@eq,d,d')))==2). Or in Octave: d(sum(triu(d==d'))==2) \$\endgroup\$

alephalpha
– alephalpha

2015-10-14 02:59:35 +00:00
Commented Oct 14, 2015 at 2:59

| Show 1 more comment

Community · Accepted Answer · 2020-06-17 09:04:33Z

6

Python 3.5, 30

[x for x in{*d}if~-d.count(x)]

Uses Python 3.5's set unpacking. The ~- subtracts 1, which takes a count of 1 to 0 which is Falsy.

This gives a list. If giving a set is OK, then we use a set comprehension, saving 1 char and not needing version 3.5:

{x for x in d if~-d.count(x)}

edited Jun 17, 2020 at 9:04

CommunityBot

1

answered Oct 13, 2015 at 21:07

xnor

150k26 gold badges287 silver badges676 bronze badges

\$\begingroup\$ SyntaxError: invalid syntax for Python 3 is it valid only for 3.5? When has python started becoming esoteric. \$\endgroup\$

garg10may
– garg10may

2015-10-14 02:08:03 +00:00
Commented Oct 14, 2015 at 2:08
\$\begingroup\$ @garg10may Just wait til you see what 3.6 has in store... \$\endgroup\$

Sp3000
– Sp3000

2015-10-14 07:45:09 +00:00
Commented Oct 14, 2015 at 7:45
1

\$\begingroup\$ @Sp3000 Awesome. Looks like the same set-up as Scala. Infinitely more readable than more alternatives. \$\endgroup\$

Carcigenicate
– Carcigenicate

2015-10-15 18:19:34 +00:00
Commented Oct 15, 2015 at 18:19

Add a comment |

Community · Accepted Answer · 2020-06-17 09:04:33Z

PowerShell, 31 29 Bytes

($d|group|?{$_.Count-1}).Name

Assumes that $d is already populated (as given) -- e.g., $d=@(-34,0,1,-34,4,8,4).

Pipes the array into the Group-Object cmdlet, which groups like-items together and spits out an object that's essentially an array of arrays. We pipe that to a Where-Object (the ? operator) that has Count greater than one (i.e., there are duplicates), and output the .Name of those items. Has a side bonus of preserving the initial ordering, too.

_{Edit - saved two bytes thanks to Danko Durbić}

I think you can replace $_.Count-gt1 with $_.Count-1 which would be true for any Count greater than one. — Danko Durbić
– Danko Durbić, Commented Oct 13, 2015 at 22:03

Digital Trauma · Accepted Answer · 2015-10-13 16:15:36Z

5

Shell + GNU coreutils, 12

sort|uniq -d

Test output:

$ printf "%s\n" -34 0 1 -34 4 8 4 | ./nonuniq.sh -34 4 $

answered Oct 13, 2015 at 16:15

Digital Trauma

73.8k10 gold badges117 silver badges268 bronze badges

Add a comment |

Glen O · Accepted Answer · 2015-10-13 18:07:00Z

Julia, 30 29 bytes

∪(d[find(sum(d.==d',1)-1)])

d.==d' creates a symmetric matrix with the value at i,j being true if d[i]==d[j] and false otherwise. summing in one dimension and then subtracting 1 will produce zero if there's only one of the element and nonzero if there's more than one. find will obtain the indexes of the non-zero elements, which are then used to index the array d itself. ∪ (union) acts like unique when used in this way, removing the repeats.

Old solution:

∪(filter(i->sum(d.==i)>1,d))

Simple - for each entry, it checks if there's more than one of it in the array. Those for which there are more than one are returned by "filter", and then ∪ (union) acts like unique when used in this way, removing the repeats.

Note: originally had it as a function, but question allows array to be stored in a variable, for which I've chosen d as suggested in the question.

Community · Accepted Answer · 2017-04-13 12:39:10Z

5

Octave, 22 bytes

Based on Luis Mendo's answer.

d(sum(triu(d==d'))==2)

edited Apr 13, 2017 at 12:39

CommunityBot

1

answered Oct 14, 2015 at 9:27

alephalpha

51.9k7 gold badges75 silver badges197 bronze badges

Add a comment |

Community · Accepted Answer · 2020-06-17 09:04:33Z

5

R, 31 24 bytes

Thanks to flodel for the 7 bytes.

Assuming the input is already in d.

code:

unique(d[duplicated(d)])

edit: now it outputs correctly if there are more than 2 duplicates as pointed by aditsu.

edited Jun 17, 2020 at 9:04

CommunityBot

1

answered Oct 13, 2015 at 13:59

Mutador

1,43110 silver badges15 bronze badges

2

\$\begingroup\$ That looks beautiful! But the 4th test case doesn't seem to be correct... \$\endgroup\$

aditsu quit because SE is EVIL
– aditsu quit because SE is EVIL

2015-10-13 14:51:39 +00:00
Commented Oct 13, 2015 at 14:51
1

\$\begingroup\$ You can remove which since [ also accepts a logical argument. \$\endgroup\$

flodel
– flodel

2015-10-14 04:31:37 +00:00
Commented Oct 14, 2015 at 4:31

Add a comment |

Community · Accepted Answer · 2020-06-17 09:04:33Z

4

Mathematica, 31 29

Cases[{s_,t_/;t>1}:>s]@*Tally

edited Jun 17, 2020 at 9:04

CommunityBot

1

answered Oct 13, 2015 at 10:59

alephalpha

51.9k7 gold badges75 silver badges197 bronze badges

Add a comment |

izzyg · Accepted Answer · 2015-10-13 23:28:29Z

Pyth, 7 bytes

ft/QT{Q

Explanation:

ft/QT{Q Q = eval(input()) {Q set(Q) - deduplicate f filter - with T as the filter variable. /QT count in Q of T t minus 1.

The filter removes all elements that appear exactly once from the set of elements.

noisyass2 · Accepted Answer · 2015-10-14 02:12:49Z

4

LINQ,62 54 bytes

Kinda new here, but here goes nothing.

d.GroupBy(c=>c).Where(g=>g.Count()>1).Select(g=>g.Key)

edited Oct 14, 2015 at 2:12

answered Oct 14, 2015 at 1:04

noisyass2

2212 silver badges5 bronze badges

\$\begingroup\$ Welcome to the site! I don't know LINQ, but there's some whitespace you can probably remove from this to improve your score. \$\endgroup\$

DLosc
– DLosc

2015-10-14 02:05:32 +00:00
Commented Oct 14, 2015 at 2:05

Add a comment |

Community · Accepted Answer · 2020-06-17 09:04:33Z

4

Python 2.7, 36 42

list(set(filter(lambda x:d.count(x)>1,d)))

edit : surrounded the expression with list(..) in order to comply with the format required in the question

edited Jun 17, 2020 at 9:04

CommunityBot

1

answered Oct 13, 2015 at 11:19

dieter

2,04617 silver badges19 bronze badges

\$\begingroup\$ this will output set not a list \$\endgroup\$

garg10may
– garg10may

2015-10-13 12:49:27 +00:00
Commented Oct 13, 2015 at 12:49
\$\begingroup\$ So shall I surround my snippet with a call to list(...) ? \$\endgroup\$

dieter
– dieter

2015-10-13 13:33:16 +00:00
Commented Oct 13, 2015 at 13:33
\$\begingroup\$ Yes the output should be an array only. \$\endgroup\$

garg10may
– garg10may

2015-10-14 01:59:16 +00:00
Commented Oct 14, 2015 at 1:59

Add a comment |

Community · Accepted Answer · 2020-06-17 09:04:33Z

4

K (not K5), 10 bytes

x@&1<#:'=x

Assumes input is in x. I thought it'd be fun to do a non-K5 answer!

edited Jun 17, 2020 at 9:04

CommunityBot

1

answered Oct 15, 2015 at 20:49

kirbyfan64sos

9,2081 gold badge27 silver badges47 bronze badges

\$\begingroup\$ Assuming k4, & on a dictionary obviates the need for x@; it can also be made tacit as &1<#:'=: for 8 bytes (dropping the need for x to be initialized). As an aside, the order of the inputs is preserved either way. \$\endgroup\$

coltim
– coltim

2020-12-07 19:12:34 +00:00
Commented Dec 7, 2020 at 19:12

Add a comment |

Community · Accepted Answer · 2020-06-17 09:04:33Z

4

Python 3 - 33 30 bytes

{_ for _ in d if d.count(_)>1}

Repl output, d as input.

edited Jun 17, 2020 at 9:04

CommunityBot

1

answered Oct 13, 2015 at 12:53

The Fifth Marshal

6,2631 gold badge27 silver badges46 bronze badges

Add a comment |

mkst · Accepted Answer · 2018-08-28 21:06:30Z

K (oK), 7 bytes

Solution:

&1<#:'=

Try it online!

Explanation:

&1<#:'= / the solution = / group, key => value (index) #:' / count length of each group 1< / 1 less than & / keys where true

Dominic van Essen · Accepted Answer · 2020-12-07 22:54:47Z

Husk, 4 bytes

u-u¹

Try it online!

u # unique element of - # set difference between u¹ # unique elements of input # and input

Wheat Wizard · Accepted Answer · 2023-01-06 03:27:55Z

Haskell + hgl, 11 10 bytes

(!!1)~<<bg

Attempt This Online!

Explanation

bg sort a list into lists of like values.
(!!1) get the second value or [] if there is none.

We use ~<< to glue these together, which basically acts as a concat map.

Reflection

This works pretty well, but the operator precedence is killing me. Both of the following work but requires the parens to prevent an error.

nb<(df^*nb) nb<(fdf~<nb)

If the operator precedence was different both of these would be competitive with the first one actually saving bytes.

I don't know if that means the precedence is wrong, but it's worth noticing.

(!!) should have a prefix function, and a bunch of versions with the index prefilled. I noticed this earlier but still didn't fix it, and now it's coming back to haunt me.

LLlAMnYP · Accepted Answer · 2015-10-15 07:30:42Z

Mathematica, 23 bytes

With input stored in d:

Pick[#,#2>1]&@@@Tally@d

As a function, 24 bytes:

Pick[#,#2>1]&@@@Tally@#&

for example, with

d = {3, 0, 0, 1, 1, 0, 5, 3} Tally@d

returns this:

 {{3, 2}, {0, 3}, {1, 2}, {5, 1}}

(first element of each sublist is the element, second one is frequency of occurrence). Applying to this list Pick[#,#2>1]&@@@ transforms it to

{Pick[3,2>1], Pick[0,3>1], Pick[1,2>1], Pick[5,1>1]}

And where the second argument of Pick evaluates to True the first argument is returned.

Brad Gilbert b2gills · Accepted Answer · 2015-10-27 22:32:25Z

Perl 6, 16 bytes

Assuming the list is stored in $_ you could use any of the following snippets.
_{^{( which was specifically allowed )}}

(--«.BagHash).Set.keys # 23 bytes

keys .Bag (-) .Set # 18 bytes

# U+2216 SET MINUS keys .Bag∖.Set # 16 bytes in utf8

If you don't care that you get a Bag you could leave off keys .

$_ = [3, 0, 0, 1, 1, 0, 5, 3]; .Bag∖.Set ∋ 3 # True .Bag∖.Set ∋ 5 # False

None of these have the limitation of only working on signed integers, or even just numbers for that matter.

say keys .Bag∖.Set given |(<a b c d a a c>), 1/3, 2/3 - 1/3; # (a c 0.333333)

Cristian Lupascu · Accepted Answer · 2020-12-07 18:37:15Z

3

Ruby, 30 28 bytes

In the Interactive Ruby Shell:

d.select{|x|d.count(x)>1}|[]

^{Saved 2 bytes thanks to Kirill L.}

edited Dec 7, 2020 at 18:37

answered Oct 13, 2015 at 13:13

Cristian Lupascu

8,6892 gold badges26 silver badges52 bronze badges

1

\$\begingroup\$ Save 2 bytes: d.select{|x|d.count(x>1)}|[] \$\endgroup\$

Kirill L.
– Kirill L.

2018-08-30 09:05:12 +00:00
Commented Aug 30, 2018 at 9:05
2

\$\begingroup\$ I think you mean count(x)>1, not count(x>1). \$\endgroup\$

David Moles
– David Moles

2020-12-05 00:48:46 +00:00
Commented Dec 5, 2020 at 0:48

Add a comment |

The Thonnu · Accepted Answer · 2023-01-04 14:57:36Z

Thunno `D`, \$7 \log_{256}(96) \approx\$ 5.76 bytes

Note: this only works on Thunno 1.1.3+

gc1>kZU

(No ATO link since that's on v1.1.0 at the moment)

Explanation

gc1>kZU # Implicit input. The D flag duplicates it implicitly. g k # Filter the input for elements where the following is truthy: c # The count of the element in the input 1> # Is greater than 1 ZU # Deduplicate and output implicitly

Shaggy · Accepted Answer · 2023-01-06 10:27:25Z

3

JavaScript, 35 28 34 bytes

a=>a.filter(o=x=>(o[x]=-~o[x])==2)

Try It Online!

edited Jan 6, 2023 at 10:27

answered May 8, 2017 at 16:49

Shaggy

45k4 gold badges39 silver badges95 bronze badges

\$\begingroup\$ Return [0,0,0] for [0,0,0,0,0,0], intended? \$\endgroup\$

l4m2
– l4m2

2023-01-06 04:36:52 +00:00
Commented Jan 6, 2023 at 4:36
\$\begingroup\$ @l4m2, fixed that. \$\endgroup\$

Shaggy
– Shaggy

2023-01-06 10:27:38 +00:00
Commented Jan 6, 2023 at 10:27

Add a comment |

Community · Accepted Answer · 2020-06-17 09:04:33Z

2

Common Lisp, 57 bytes

(remove-duplicates(remove-if(lambda(x)(<(count x d)2))d))

edited Jun 17, 2020 at 9:04

CommunityBot

1

answered Oct 13, 2015 at 13:11

nanny

1813 bronze badges

Add a comment |

Non-Unique/Duplicate Elements

Test Cases

63 Answers 63

K5, 5 bytes

Edit:

CJam, 10

Standard input/output version, 13:

Haskell - 32

Pyth, 7 bytes

How it works

SQL, 44 42 bytes

APL (Dyalog Unicode), 13 9 bytesSBCS

Mathematica, 29 26 bytes

JavaScript (ES6), 37 bytes

Matlab / Octave, 40

Python 3.5, 30

PowerShell, 31 29 Bytes

Shell + GNU coreutils, 12

Test output:

Julia, 30 29 bytes

Octave, 22 bytes

R, 31 24 bytes

code:

Mathematica, 31 29

Pyth, 7 bytes

LINQ,62 54 bytes

Python 2.7, 36 42

K (not K5), 10 bytes

Python 3 - 33 30 bytes

K (oK), 7 bytes

Husk, 4 bytes

Haskell + hgl, 11 10 bytes

Explanation

Reflection

Mathematica, 23 bytes

Perl 6, 16 bytes

Ruby, 30 28 bytes

Thunno D, \$7 \log_{256}(96) \approx\$ 5.76 bytes

Explanation

JavaScript, 35 28 34 bytes

Common Lisp, 57 bytes

Linked

Related

Hot Network Questions

APL (Dyalog Unicode), 13 9 bytes^SBCS

Thunno `D`, \$7 \log_{256}(96) \approx\$ 5.76 bytes