编写一个程序，查找有符号整数数组的非唯一元素。结果数组可以是任何顺序。

您的答案可能是一个片段，该片段假定输入要存储在变量中（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]

元素的顺序无关紧要。

这是代码高尔夫球，因此最短的答案（以字节为单位）获胜。

K5个字节

假设输入已经在名为的变量中d，

?d^?d

取?d 的不同元素（），除了（d^）d 的不同元素（?d）。很好地对称，不是吗？之所以有效，是因为“ except”运算符仅从左参数中删除右参数的第一个匹配项。

更普遍，

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)

果酱，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如果要漂亮打印，请附加a ，否则默认情况下只打印出没有定界符的结果数组。这是可以接受的，因为问题指定代码段仅需要“评估为正确的结果”。

标准输入/输出版本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删除每个元素的第一个匹配项，并使列表的所有元素唯一。banub

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和其他可能的版本中工作。感谢2个字节中的@manatwork。

Mathematica， 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 /八度，40

我假设输入值是真实的（不复杂）。输入在变量中d。

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

在Octave中在线尝试。

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-Objectcmdlet中，该cmdlet将相似项分组在一起，并吐出一个对象，该对象本质上是数组的数组。我们通过管道将其传送给一个大于（即有重复项）的Where-Object（?运算符Count），并输出.Name这些项的。也有保留初始顺序的额外好处。

_{编辑-感谢DankoDurbić，节省了两个字节}

APL（Dyalog Unicode），13个 9 字节^SBCS

匿名默认前缀功能。

∊(⊂1↓⊣¨)⌸

在线尝试！

(… )⌸ 对于每个唯一元素（左参数）及其出现的索引（右参数），应用以下默认函数：

 ⊣¨ 左边的一个（唯一元素），右边的每个（索引）

 1↓ 掉一个

 ⊂ 封闭（防止用零填充以创建不粗糙的矩阵）

∊ ε NLIST（扁平化）

朱莉娅，30 29字节

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

d.==d'创建一个对称矩阵，其值i,j如果为true ，则为true 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)))

编辑：用list（..）包围表达式，以便符合问题中要求的格式

八度，22字节

基于Luis Mendo的答案。

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

R，31 24字节

感谢flodel提供了7个字节。

假设输入已经在中d。

码：

unique(d[duplicated(d)])

编辑：现在，如果aditsu指出的重复项超过2个，它将正确输出。

Python 3-33 30字节

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

复制输出，d作为输入。

Mathematica，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
$ 

Mathematica，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)

Ruby，30个 28字节

在交互式Ruby Shell中：

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

^{感谢Kirill L，节省了2个字节。}

JavaScript，35 28字节

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

在线尝试！

发布此内容后，我意识到它与w0lf的解决方案非常相似。

Common Lisp，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个字节。感谢JörgHülsermann。array_diff_assocarray_diff_key