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

Ваша відповідь може бути фрагментом, який передбачає, що вхід зберігається у змінній ( 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

Хаскелл - 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)

Матлаб / Октава, 40

Я припускаю, що вхідні значення реальні (не складні). Вхід є змінною d.

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

Спробуйте його онлайн в Octave.

Пітон 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командлет, який об'єднує однотипні елементи разом і виділяє об'єкт, який по суті є масивом масивів. Ми передаємо це Where-Object( ?оператору), у якого Countбільше одного (тобто є дублікати), і виводимо висновки .Nameцих елементів. Також є боковий бонус за збереження початкового замовлення.

_{Редагувати - збережено два байти завдяки Данко Дурбичу}

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

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

∊(⊂1↓⊣¨)⌸

Спробуйте в Інтернеті!

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

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

 1↓ скинути один

 ⊂ укласти (запобігає прокладці нулями для створення не рваної матриці)

∊ ϵ список (згладити)

Джулія, 30 29 байт

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

d.==d'створює симетричну матрицю, значення якої i,jє істинним, якщо d[i]==d[j]і неправдивим інакше. summing в одному вимірі, а потім віднімання 1 призведе до нуля, якщо є лише один елемент, а ненульовий, якщо є більше одного. findотримають індекси ненульових елементів, які потім використовуються для індексації самого масиву d. ∪(союз) діє якunique коли використовується таким чином, видаляючи повтори.

Старе рішення:

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

Простий - для кожного запису він перевіряє, чи є в масиві більше одного. Ті, для яких є більше одного, повертаються «фільтром», а потім ∪(об'єднання) діє такunique при використанні таким чином, видаляючи повтори.

Примітка: спочатку він мав його як функцію, але питання дозволяє масиву зберігатись у змінній, для якої я обрав dяк запропонований у питанні.

Пітон 2.7, 36 42

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

редагувати : оточив вираз списком (..), щоб відповідати формату, необхідному у запитанні

Октава, 22 байти

На основі відповіді Луїса Мендо .

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

R, 31 24 байт

Завдяки флоделі за 7 байт.

Припустимо, що вхід уже входить d.

код:

unique(d[duplicated(d)])

редагувати: тепер він виводить правильно, якщо є більше двох дублікатів, як вказано на aditsu .

Python 3 - 33 30 байт

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

Repl вихід, dяк вхід.

Математика, 31 29

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

Pyth, 7 байт

ft/QT{Q

Пояснення:

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.

Фільтр видаляє всі елементи, які з’являються рівно один раз із набору елементів.

LINQ, 62 54 байти

Тут щось нове, але тут нічого не йде.

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

K (oK) , 7 байт

Рішення:

&1<#:'=

Спробуйте в Інтернеті!

Пояснення:

&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

Тестовий вихід:

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

Математика, 23 байти

З входом, збереженим у d:

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

Як функція, 24 байти:

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

наприклад, с

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

повертає це:

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

(перший елемент кожного списку - це елемент, другий - частота появи). Застосування до цього списку Pick[#,#2>1]&@@@перетворює його на

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

І там, де повертається другий аргумент Pickоцінки, до Trueпершого аргументу.

K (не K5), 10 байт

x@&1<#:'=x

Припускає, що вхід є в x. Я подумав, що було б весело зробити відповідь, що не K5!

Perl 6, 16 байт

Якщо припустити, що список зберігається у $_вас, ви можете використовувати будь-який із наведених нижче фрагментів.
_{^{(що було дозволено спеціально)}}

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

keys .Bag (-) .Set # 18 bytes

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

Якщо вам не байдуже, що ви отримаєте Сумку, ви можете піти keys .

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

Жодне з них не має обмеження працювати лише над підписаними цілими числами або навіть просто числами з цього питання.

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

Рубін, 30 28 байт

В інтерактивній оболонці Ruby :

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

^{Збережено 2 байти завдяки Кирилу Л.}

JavaScript, 35 28 байт

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

Спробуйте в Інтернеті!

Опублікувавши це, я зрозумів, що це дуже схоже на рішення w0lf .

Лист звичайний, 57 байт

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

Октава, 33 байти

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

• Знаходить показники першого виникнення кожного унікального цілого числа,
• видаляє ці події та
• знаходить унікальні елементи масиву, що залишився.

Ось це на ideone . Я завернув фрагмент у функцію, щоб я міг викликати його, використовуючи всі зразки даних.

Java 8, 80 байт

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

Припускаючи, що x містить вхідний Список чисел.

PHP, 35 37 байт

Досить прямо вперед:

array_diff_key($a,array_unique($a))

Як зауваження: я не додав ;кінець рядка, як зазначено в запитаннях:

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

Тож цей фрагмент можна використовувати так і оцінює правильний результат:

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

Ще одна примітка

Наведений вище код працює для всіх тестових випадків, передбачених у виклику. У них усі не унікальні символи є максимум дублікатами. Якщо елемент може виникнути більше ніж у два рази, array_unique()знадобиться інший , який збільшує довжину до 49 байт :

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

Правки

• Збережено 2 байти заміною array_diff_assocна array_diff_key. Завдяки Йоргу Гюльсерману .