Napisz program, który znajdzie nieunikalne elementy tablicy liczb całkowitych ze znakiem. Powstała tablica może być w dowolnej kolejności.

Twoja odpowiedź może być fragmentem, który zakłada, że ​​dane wejściowe są przechowywane w zmiennej ( dpowiedzmy) i ocenia poprawny wynik.

Przypadki testowe

Każdy przypadek testowy jest pojedynczą linią w formacie input => output. Zauważ, że inne kombinacje danych wyjściowych są również poprawne.

[]                        => []
[-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]

Kolejność elementów nie ma znaczenia.

To jest kod golfowy, więc wygrywa najkrótsza odpowiedź (w bajtach).

K5 , 5 bajtów

Zakładając, że wejście jest już w zmiennej o nazwie d,

?d^?d

Weź odrębne elementy ( ?) z wyjątkiem ( d^) odrębnych elementów d ( ?d). Ładnie symetryczne, nie? Działa to, ponieważ operator „oprócz” usuwa tylko pierwsze wystąpienie prawego argumentu z lewego argumentu.

Bardziej ogólnie,

nu: {?x^?x}

W akcji:

  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)

Edytować:

Gdybyśmy chcieli zachować kolejność pierwszego wystąpienia nieunikalnych elementów, moglibyśmy odwrócić listę źródłową przed i po usunięciu unikalnych elementów, za wyjątkiem kosztu 4 dodatkowych bajtów:

  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)

CJam, 10

Zakładając, że tablica jest już w zmiennej D (na podstawie tego komentarza ):

D{De=(},_&

Wypróbuj online

Wyjaśnienie:

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

Uwaga: dodaj, pjeśli chcesz ładnego drukowania, w przeciwnym razie tablica wynikowa zostanie po prostu wydrukowana bez domyślnych ograniczników. Jest to do przyjęcia, ponieważ pytanie określa, że ​​fragment kodu musi jedynie „ocenić prawidłowy wynik”.

Standardowa wersja wejścia / wyjścia, 13:

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

Wypróbuj online

Wyjaśnienie:

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

Haskell - 32

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

Całkiem krótko, nawet przy imporcie. a \\ busuwa pierwsze wystąpienie każdego elementu bz ai nubczyni wszystkie elementy listy unikalnymi.

Pyth, 7 bajtów

S{.-Q{Q

Wypróbuj online.

Jak to działa

Pyth automatycznie zapisuje oszacowane dane wejściowe Qi drukuje wszystkie nieużywane wartości zwracane.

     {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.

SQL, 44 42 bajty

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

Mam nadzieję, że można założyć, że liczby całkowite są zapisane w tabeli D? Będzie to działać zarówno w SQLServer, PostgreSQL i ewentualnie w innych. Dzięki @manatwork z 2 bajtów.

Mathematica, 29 26 bajtów

Zakładając, że dane wejściowe są przechowywane w d:

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

W przeciwnym razie jest to 29 bajtów jako funkcja bez nazwy:

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

Tutaj d⋃d(lub #⋃#) jest golfowa sztuczka polegająca na usuwaniu duplikatów - łącząc zbiór ze sobą, Mathematica interpretuje listę jako zbiór, usuwając duplikaty automatycznie, podczas gdy rzeczywisty związek nic nie robi.

Następnie obie metody po prostu filtrują te elementy, które pojawiają się na oryginalnej liście co najmniej dwukrotnie.

JavaScript (ES6), 37 bajtów

Uruchom to w konsoli JavaScript:

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

Matlab / Octave, 40

Zakładam, że wartości wejściowe są rzeczywiste (nie złożone). Dane wejściowe są w zmiennej d.

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

Wypróbuj online w Octave.

Python 3.5, 30

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

Używa rozpakowywania zestawu Python 3.5. The~- odejmuje 1, która odbywa się liczyć od 1 do 0, które jest Falsy.

To daje listę. Jeśli podanie zestawu jest w porządku, używamy zrozumienia zestawu, oszczędzając 1 znak i nie potrzebując wersji 3.5:

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

PowerShell, 31 29 bajtów

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

Zakłada, że $djest już wypełniony (jak podano) - np $d=@(-34,0,1,-34,4,8,4).

Pipuje tablicę do Group-Objectcmdleta, który grupuje podobne elementy i wypluwa obiekt, który jest w zasadzie tablicą tablic. Potokujemy to doWhere-Object ( ?operatora), który ma Countwięcej niż jeden (tzn. Istnieją duplikaty), i wysyłamy .Namete elementy. Ma dodatkowy bonus związany z zachowaniem początkowego zamówienia.

_{Edycja - zapisane dwa bajty dzięki Danko Durbićowi}

APL (Dyalog Unicode) , 13 9 bajtów ^SBCS

Anonimowa ukryta funkcja prefiksu.

∊(⊂1↓⊣¨)⌸

Wypróbuj online!

(…)⌸  Dla każdego unikalnego elementu (lewy argument) i indeksów, w których występuje (prawy argument), zastosuj następującą ukrytą funkcję:

 ⊣¨ jeden z lewej (unikalny element) dla każdego z prawej (indeksy)

 1↓ upuść jeden

 ⊂ dołącz (zapobiega wypełnianiu zerami, aby utworzyć niewyrównaną macierz)

∊ ε nlist (spłaszczyć)

Julia, 30 29 bajtów

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

d.==d'tworzy macierz symetryczną o wartości i,jtrue, jeśli w d[i]==d[j]przeciwnym razie false. sumpołączenie w jednym wymiarze, a następnie odjęcie 1 da zero, jeśli jest tylko jeden element, i niezerowe, jeśli jest więcej niż jeden. findotrzyma indeksy niezerowych elementów, które są następnie używane do indeksowania dsamej tablicy . ∪(unia) działa tak, jak uniquew takim użyciu, usuwając powtórzenia.

Stare rozwiązanie:

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

Prosty - dla każdego wpisu sprawdza, czy w tablicy jest więcej niż jeden. Te, dla których jest więcej niż jeden, są zwracane przez „filtr”, a następnie ∪(związek) zachowuje się jakunique użyte w ten sposób, usuwając powtórzenia.

Uwaga: pierwotnie miał to jako funkcję, ale pytanie pozwala na przechowywanie tablicy w zmiennej, dla której wybrałem dzgodnie z sugestią w pytaniu.

Python 2.7, 36 42

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

edit : otaczał wyrażenie listą (...), aby zachować zgodność z formatem wymaganym w pytaniu

Oktawa, 22 bajty

Na podstawie odpowiedzi Luisa Mendo .

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

R, 31 24 bajtów

Dzięki flodel for the 7 bytes.

Zakładając, że wejście jest już w d.

kod:

unique(d[duplicated(d)])

edycja: teraz wyświetla poprawnie, jeśli są więcej niż 2 duplikaty wskazane przez aditsu .

Python 3 - 33 30 bytes

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

Repl output, d as input.

Mathematica, 31 29

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

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.

LINQ,62 54 bytes

Kinda new here, but here goes nothing.

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

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

Shell + GNU coreutils, 12

sort|uniq -d

Test output:

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

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.

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!

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)

Ruby, 30 28 bytes

In the Interactive Ruby Shell:

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

^{Saved 2 bytes thanks to Kirill L.}

JavaScript, 35 28 bytes

a=>a.filter(o=x=>!(o[x]^=1))

Try It Online!

After posting this, I realised that it was very similar to w0lf's solution.

Common Lisp, 57 bytes

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

Octave, 33 bytes

[~,a]=unique(d);d(a)=[];unique(d)

• Finds the indices of the first occurrence of each unique integer,
• removes those occurrences, and
• finds the unique elements of the remaining array.

Here it is on ideone. I've wrapped the snippet in a function so I could call it using all of the sample inputs.

Java 8, 80 Bytes

x.stream().filter(i->x.indexOf(i)!=x.lastIndexOf(i)).collect(Collectors.toSet())

Assuming x contains the input List of numbers.

PHP, 35 37 bytes

Pretty straight forward:

array_diff_key($a,array_unique($a))

As a note: I didn't add the ; at the end of the line, as the questions states:

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

So this snippet could be used like this and evaluates to the correct result:

print implode(' ', array_diff_key($a,array_unique($a)));

Another note

The code above works for all test cases provided in the challenge. In those all non-unique characters are at most duplicates. If a element can occur more than two times, another array_unique() would be necessary, which increases the length to 49 bytes:

array_unique(array_diff_key($a,array_unique($a)))

Edits

• Saved 2 bytes by replacing array_diff_assoc with array_diff_key. Thanks to Jörg Hülsermann.