Напишите программу, которая находит неуникальные элементы массива целых чисел со знаком. Полученный массив может быть в любом порядке.

Ваш ответ может быть фрагментом, который предполагает, что ввод будет сохранен в переменной ( dскажем) и оценивает правильный результат.

Тестовые случаи

Каждый тестовый пример представляет собой одну строку в формате input => output. Обратите внимание, что другие перестановки вывода также действительны.

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

Порядок элементов не имеет значения.

Это код гольф, поэтому самый короткий ответ (в байтах) выигрывает.

К5 , 5 байт

Предполагая, что вход уже находится в переменной с именем d,

?d^?d

Возьмите различные элементы ( ?) из d, кроме (d^ ) различных элементов из d ( ?d). Красиво симметрично, нет? Это работает, потому что оператор «кроме» удаляет только первое вхождение правого аргумента из левого аргумента.

В более общем смысле,

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
 0 1 3
 -34 4)

Редактировать:

Если бы мы хотели сохранить порядок первого появления неуникальных элементов, мы могли бы изменить список источников до и после удаления уникальных элементов с помощью, за исключением 4 дополнительных байтов:

  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

Предполагая, что массив уже находится в переменной D (на основе этого комментария ):

D{De=(},_&

Попробуйте онлайн

Объяснение:

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

Примечание: добавьте p если вы хотите красивую печать, иначе полученный массив просто распечатывается без разделителей по умолчанию. Это приемлемо, поскольку в вопросе указывается, что фрагменту нужно только «оценить правильный результат».

Стандартная версия ввода / вывода, 13:

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

Попробуйте онлайн

Объяснение:

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

Довольно короткий, даже с учетом импорта. a \\ bудаляет первое вхождение каждого элемента bиз aи nubделает все элементы списка уникальными.

Pyth, 7 байт

S{.-Q{Q

Попробуйте онлайн.

Как это работает

Pyth автоматически сохраняет оцененные входные данные Qи печатает все неиспользуемые возвращаемые значения.

     {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 байта

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

Я надеюсь, что можно предположить, что целые числа хранятся в таблице D? Это будет работать как в SQLServer, PostgreSQL, так и, возможно, в других. Благодаря @manatwork из 2 байтов.

Математика, 29 26 байт

Предполагая, что вход хранится в d:

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

В противном случае, это 29 байтов как безымянная функция:

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

Здесь d⋃d(или #⋃#) это игра в гольф для удаления дубликатов - принимая объединение наборов с собой, Mathematica интерпретирует список как набор, автоматически удаляя дубликаты, в то время как фактическое объединение ничего не делает.

После этого оба метода просто фильтруют те элементы, которые появляются в исходном списке как минимум дважды.

JavaScript (ES6), 37 байт

Запустите это в консоли JavaScript:

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

Matlab / Octave, 40

Я предполагаю, что входные значения реальны (не сложны). Ввод в переменной d.

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

Попробуйте это онлайн в Октаве.

Python 3.5, 30

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

Использует распакованный набор Python 3.5. ~- вычитает 1, который принимает отсчет от 1 до 0 , который является Falsy.

Это дает список. Если предоставление набора в порядке, тогда мы используем понимание набора, сохраняя 1 символ и не нуждаясь в версии 3.5:

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

PowerShell, 31 29 байт

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

Предполагается , что $dуже заселена (как указано) - например, $d=@(-34,0,1,-34,4,8,4).

Передает массив в Group-Objectкомандлет, который группирует элементы Like и выделяет объект, который по сути является массивом массивов. Мы передаем это в Where-Object( ?оператор), который имеет Countбольше одного (то есть, есть дубликаты), и выводим .Nameэти элементы. Имеет побочный бонус сохранения первоначального заказа тоже.

_{Edit - сохранил два байта благодаря Данко Дурбичу}

APL (Dyalog Unicode) , 13 9 байтов ^SBCS

Функция анонимного молчаливого префикса.

∊(⊂1↓⊣¨)⌸

Попробуйте онлайн!

(… )⌸ Для каждого уникального элемента (левый аргумент) и индексов, где он встречается (правый аргумент), примените следующую скрытую функцию:

 ⊣¨ один слева (уникальный элемент) для каждого справа (индексы)

 1↓ брось один

 ⊂ enclace (предотвращает заполнение нулями для создания неповрежденной матрицы)

∊ ε NLIST (Flatten)

Юлия, 30 29 байт

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

d.==d'создает симметричную матрицу со значением i,jtrue, если d[i]==d[j]и false в противном случае. sumЕсли в одном измерении затем вычесть 1, то получится ноль, если есть только один элемент, и ненулевое значение, если их больше одного. findполучит индексы ненулевых элементов, которые затем используются для индексации самого массива d. ∪(объединение) действует как uniqueпри использовании таким образом, удаляя повторы.

Старое решение:

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

Просто - для каждой записи проверяется, есть ли в массиве более одной записи. Те, для которых их более одного, возвращаются фильтром, а затем ∪(объединение) действует какunique при использовании таким образом, удаляя повторы.

Примечание: изначально он был как функция, но вопрос позволяет хранить массив в переменной, для которой я выбрал, dкак предложено в вопросе.

Python 2.7, 36 42

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

edit : окружил выражение списком (..) для соответствия формату, необходимому в вопросе

Octave, 22 bytes

Based on Luis Mendo's answer.

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

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.

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.