Escreva um programa que encontre os elementos não exclusivos de uma matriz de números inteiros assinados. A matriz resultante pode estar em qualquer ordem.

Sua resposta pode ser um trecho que assume que a entrada deve ser armazenada em uma variável ( ddigamos) e avalia o resultado correto.

Casos de teste

Cada caso de teste é uma única linha no formato input => output. Observe que outras permutações da saída também são válidas.

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

A ordem dos elementos não importa.

Isso é código de golfe, então a resposta mais curta (em bytes) vence.

K5 , 5 bytes

Assumindo que a entrada é já em uma variável chamada d,

?d^?d

Tome os elementos distintos ( ?) de d, exceto ( d^) os elementos distintos de d ( ?d). Bem simétrico, não? Isso funciona porque o operador "exceto" remove apenas a primeira ocorrência do argumento correto do argumento esquerdo.

Geralmente mais,

nu: {?x^?x}

Em ação:

  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)

Editar:

Se quiséssemos preservar a ordem da primeira ocorrência de elementos não exclusivos, poderíamos reverter a lista de fontes antes e depois de remover os elementos exclusivos via, exceto pelo custo de 4 bytes extras:

  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

Supondo que a matriz já esteja na variável D (com base neste comentário ):

D{De=(},_&

Experimente online

Explicação:

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

Nota: anexe a pse desejar uma impressão bonita, caso contrário, a matriz resultante será impressa sem delimitadores por padrão. Isso é aceitável, pois a pergunta especifica que o snippet precisa apenas "avaliar o resultado correto".

Versão padrão de entrada / saída, 13:

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

Experimente online

Explicação:

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

Muito curto, mesmo com a importação. a \\ bremove a primeira ocorrência de cada elemento da ba partir de a, e nubfaz com que todos os elementos de uma lista exclusiva.

Pitão, 7 bytes

S{.-Q{Q

Experimente online.

Como funciona

Pyth armazena automaticamente a entrada avaliada Qe imprime todos os valores de retorno não utilizados.

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

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

Espero que seja correto assumir que os números inteiros estão armazenados na tabela D? Isso funcionará no SQLServer, PostgreSQL e possivelmente em outros. Graças a @manatwork a partir dos 2 bytes.

Mathematica, 29 26 bytes

Supondo que a entrada seja armazenada em d:

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

Caso contrário, são 29 bytes como uma função sem nome:

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

Aqui, d⋃d(ou #⋃#) é um truque de golfe para remover duplicatas - levando a união do conjunto consigo, o Mathematica interpreta a lista como um conjunto, removendo as duplicatas automaticamente, enquanto a união real não faz nada.

Depois, ambos os métodos simplesmente filtram os elementos que aparecem na lista original pelo menos duas vezes.

JavaScript (ES6), 37 bytes

Execute isso no console do JavaScript:

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

Matlab / Oitava, 40

Estou assumindo que os valores de entrada são reais (não complexos). A entrada está em uma variável d.

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

Experimente online no Octave.

Python 3.5, 30

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

Usa o conjunto de descompactação do Python 3.5. O ~-subtrai 1, que conta de 1 a 0, que é Falsy.

Isso dá uma lista. Se fornecer um conjunto estiver OK, usamos uma compreensão do conjunto, economizando 1 caractere e não necessitando da versão 3.5:

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

PowerShell, 31 29 bytes

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

Assume que $djá está preenchido (conforme fornecido) - por exemplo $d=@(-34,0,1,-34,4,8,4),.

Coloca a matriz no Group-Objectcmdlet, que agrupa itens semelhantes e cospe um objeto que é essencialmente uma matriz de matrizes. Nós canalizamos isso para um Where-Object( ?operador) que tem Countmais de um (ou seja, existem duplicatas) e produzimos .Nameesses itens. Tem um bônus adicional de preservar a ordem inicial também.

_{Editar - salvou dois bytes graças a Danko Durbić}

APL (Dyalog Unicode) , 13 9 bytes ^SBCS

Função de prefixo tácito anônimo.

∊(⊂1↓⊣¨)⌸

Experimente online!

(… )⌸ Para cada elemento exclusivo (argumento da esquerda) e os índices onde ocorre (argumento da direita), aplique a seguinte função tácita:

 ⊣¨ um da esquerda (o elemento exclusivo) de cada um à direita (os índices)

 1↓ soltar um

 ⊂ delimite (evita o preenchimento com zeros para criar uma matriz não irregular)

∊ ε nlist (achatar)

Julia, 30 29 bytes

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

d.==d'cria uma matriz simétrica com o valor i,jsendo verdadeiro se d[i]==d[j]e falso caso contrário. suma combinação de uma dimensão e a subtração de 1 produzirão zero se houver apenas um elemento e diferente de zero se houver mais de um. findobterá os índices dos elementos diferentes de zero, que são usados ​​para indexar a dprópria matriz . ∪(união) age como uniquequando usado dessa maneira, removendo as repetições.

Solução antiga:

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

Simples - para cada entrada, verifica se há mais de uma na matriz. Aqueles para os quais existem mais de um são retornados por "filtro" e, em seguida, ∪(união) agem como uniquequando usados ​​dessa maneira, removendo as repetições.

Nota: originalmente tinha como função, mas a pergunta permite que o array seja armazenado em uma variável, para a qual eu escolhi dcomo sugerido na pergunta.

Python 2.7, 36 42

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

editar : envolveu a expressão com lista (..) para atender ao formato exigido na pergunta

Oitava, 22 bytes

Baseado na resposta de Luis Mendo .

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

R, 31 bytes 24

Graças a flodel para os 7 bytes.

Assumindo que a entrada é já em d.

código:

unique(d[duplicated(d)])

edit: agora é exibido corretamente se houver mais de 2 duplicatas, conforme indicado pelo aditsu .

Python 3-33 30 bytes

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

Substitua a saída dcomo entrada.

Mathematica, 31 29

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

Pitão, 7 bytes

ft/QT{Q

Explicação:

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.

O filtro remove todos os elementos que aparecem exatamente uma vez do conjunto de elementos.

LINQ, 62 54 bytes

Um pouco novo aqui, mas aqui não vale nada.

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

K (oK) , 7 bytes

Solução:

&1<#:'=

Experimente online!

Explicação:

&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

Saída de teste:

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

Mathematica, 23 bytes

Com a entrada armazenada em d:

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

Em função, 24 bytes:

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

por exemplo, com

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

retorna isso:

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

(o primeiro elemento de cada sub-lista é o elemento, o segundo é a frequência de ocorrência). A aplicação a esta lista a Pick[#,#2>1]&@@@transforma em

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

E onde o segundo argumento de Pickavalia para Trueo primeiro argumento é retornado.

K (não K5), 10 bytes

x@&1<#:'=x

Assume que a entrada está inserida x. Eu pensei que seria divertido fazer uma resposta que não fosse do K5!

Perl 6, 16 bytes

Supondo que a lista esteja armazenada, $_você pode usar qualquer um dos seguintes trechos.
_{^{(que foi especificamente permitido)}}

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

keys .Bag (-) .Set # 18 bytes

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

Se você não se importa com a compra de uma bolsa, pode deixar de usá-la keys .

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

Nenhum deles tem a limitação de trabalhar apenas números inteiros assinados, ou mesmo apenas números para esse assunto.

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

No Ruby Shell interativo :

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

^{Economizou 2 bytes graças a Kirill L.}

JavaScript, 35 28 bytes

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

Experimente Online!

Depois de postar isso, percebi que era muito semelhante à solução do w0lf .

Lisp comum, 57 bytes

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

Oitava, 33 bytes

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

• Localiza os índices da primeira ocorrência de cada número inteiro único,
• remove essas ocorrências e
• localiza os elementos exclusivos da matriz restante.

Aqui está no ideone . Eu agrupei o trecho em uma função para poder chamá-lo usando todas as entradas de amostra.

Java 8, 80 bytes

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

Supondo que x contém a lista de números de entrada.

PHP, 35 37 bytes

Bem direto:

array_diff_key($a,array_unique($a))

Como observação: não adicionei o ;no final da linha, como as perguntas afirmam:

Sua resposta pode ser um trecho que assume que a entrada deve ser armazenada em uma variável (d, digamos) e avalia o resultado correto

Portanto, esse snippet pode ser usado assim e avaliado para o resultado correto:

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

Outra nota

O código acima funciona para todos os casos de teste fornecidos no desafio. Nesses, todos os caracteres não exclusivos são no máximo duplicados. Se um elemento puder ocorrer mais de duas vezes, outro array_unique()seria necessário, o que aumenta o comprimento para 49 bytes :

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

Edições

• Economizou 2 bytes substituindo array_diff_assocpor array_diff_key. Agradecimentos a Jörg Hülsermann .