Escriba un programa que encuentre los elementos no únicos de una matriz de enteros con signo. La matriz resultante puede estar en cualquier orden.

Su respuesta puede ser un fragmento que asume que la entrada se almacena en una variable ( ddigamos) y se evalúa como el resultado correcto.

Casos de prueba

Cada caso de prueba es una sola línea en el formato input => output. Tenga en cuenta que otras permutaciones de la salida también son 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]

El orden de los elementos no importa.

Este es el código de golf, por lo que gana la respuesta más corta (en bytes).

K5 , 5 bytes

Asumiendo que la entrada ya está en una variable llamada d,

?d^?d

Tome los elementos distintos ( ?) de d excepto ( d^) los elementos distintos de d ( ?d). Muy simétrico, ¿no? Esto funciona porque el operador "excepto" elimina solo la primera aparición del argumento derecho del argumento izquierdo.

Más generalmente,

nu: {?x^?x}

En acción:

  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:

Si quisiéramos preservar el orden de la primera aparición de elementos no únicos, podríamos revertir la lista fuente antes y después de eliminar los elementos únicos a través de, excepto al costo de 4 bytes adicionales:

  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

Suponiendo que la matriz ya está en la variable D (según este comentario ):

D{De=(},_&

Pruébalo en línea

Explicación:

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: agregue un psi desea una impresión bonita, de lo contrario, la matriz resultante simplemente se imprime sin delimitadores de forma predeterminada. Eso es aceptable ya que la pregunta especifica que el fragmento solo necesita "evaluar el resultado correcto".

Versión estándar de entrada / salida, 13:

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

Pruébalo en línea

Explicación:

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

Bastante corto, incluso con la importación. a \\ belimina la primera aparición de cada elemento de bfrom ay nubhace que todos los elementos de una lista sean únicos.

Pyth, 7 bytes

S{.-Q{Q

Pruébalo en línea.

Cómo funciona

Pyth almacena automáticamente la entrada evaluada Qe imprime todos los valores de retorno no 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 esté bien suponer que los enteros están almacenados en la tabla D? Esto funcionará tanto en SQLServer, PostgreSQL y posiblemente en otros. Gracias a @manatwork de los 2 bytes.

Mathematica, 29 26 bytes

Suponiendo que la entrada se almacena en d:

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

De lo contrario, son 29 bytes como una función sin nombre:

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

Aquí, d⋃d(o #⋃#) es un truco de golf para eliminar duplicados: al tomar la unión del conjunto consigo mismo, Mathematica interpreta la lista como un conjunto, eliminando duplicados automáticamente, mientras que la unión real no hace nada.

Luego, ambos métodos simplemente filtran los elementos que aparecen en la lista original al menos dos veces.

JavaScript (ES6), 37 bytes

Ejecute esto en la consola de JavaScript:

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

Matlab / Octave, 40

Supongo que los valores de entrada son reales (no complejos). La entrada está en una variable d.

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

Pruébelo en línea en Octave.

Python 3.5, 30

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

Utiliza el desempaquetado de Python 3.5. Los ~-resta 1, que toma un recuento de 1 a 0, que es Falsy.

Esto da una lista. Si dar un conjunto está bien, entonces usamos una comprensión del conjunto, guardando 1 carácter y no necesita la versión 3.5:

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

PowerShell, 31 29 bytes

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

Asume que $dya está poblada (como dado) - por ejemplo, $d=@(-34,0,1,-34,4,8,4).

Conecta la matriz al Group-Objectcmdlet, que agrupa elementos similares y escupe un objeto que es esencialmente una matriz de matrices. Lo canalizamos a un Where-Object(el ?operador) que tiene Countmás de uno (es decir, hay duplicados), y enviamos el resultado .Namede esos elementos. Tiene una ventaja adicional de preservar el pedido inicial también.

_{Editar: ahorró dos bytes gracias a Danko Durbić}

APL (Dyalog Unicode) , 13 ^SBCS de 9 bytes

Función de prefijo tácito anónimo.

∊(⊂1↓⊣¨)⌸

Pruébalo en línea!

(... )⌸ para cada elemento único (argumento izquierdo) y los índices donde ocurre (argumento derecho), aplique la siguiente función tácita:

 ⊣¨ uno de la izquierda (el elemento único) para cada uno a la derecha (los índices)

 1↓ soltar uno

 ⊂ encerrar (evita el relleno con ceros para crear una matriz no desigual)

∊ ϵ nlist (aplanar)

Julia, 30 29 bytes

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

d.==d'crea una matriz simétrica con el valor de i,jser verdadero si d[i]==d[j]y falso de lo contrario. summing en una dimensión y luego restando 1 producirá cero si solo hay uno del elemento y distinto de cero si hay más de uno. findobtendrá los índices de los elementos distintos de cero, que luego se utilizan para indexar la matriz en dsí. ∪(union) actúa como uniquecuando se usa de esta manera, eliminando las repeticiones.

Vieja solución:

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

Simple: para cada entrada, comprueba si hay más de una en la matriz. Aquellos para los que hay más de uno son devueltos por "filtro", y luego ∪(unión) actúa como uniquecuando se usa de esta manera, eliminando las repeticiones.

Nota: originalmente lo tenía como función, pero la pregunta permite que la matriz se almacene en una variable, para lo cual he elegido dcomo se sugiere en la pregunta.

Python 2.7, 36 42

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

editar : rodeó la expresión con la lista (..) para cumplir con el formato requerido en la pregunta

Octava, 22 bytes

Basado en la respuesta de Luis Mendo .

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

R, 31 24 bytes

Gracias a flodel por los 7 bytes.

Asumiendo que la entrada ya está en d .

código:

unique(d[duplicated(d)])

editar: ahora sale correctamente si hay más de 2 duplicados como lo señala aditsu .

Python 3 - 33 30 bytes

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

Salida de respuesta, dcomo entrada.

Mathematica, 31 29

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

Pyth, 7 bytes

ft/QT{Q

Explicación:

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.

El filtro elimina todos los elementos que aparecen exactamente una vez del conjunto de elementos.

LINQ, 62 54 bytes

Un poco nuevo aquí, pero aquí no pasa nada.

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

K (oK) , 7 bytes

Solución:

&1<#:'=

Pruébalo en línea!

Explicación:

&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

Prueba de salida:

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

Mathematica, 23 bytes

Con entrada almacenada en d:

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

Como una función, 24 bytes:

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

por ejemplo, con

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

devuelve esto:

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

(el primer elemento de cada sublista es el elemento, el segundo es la frecuencia de ocurrencia). Aplicar a esta lista lo Pick[#,#2>1]&@@@transforma en

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

Y donde se devuelve el segundo argumento de Pickevalúa al Trueprimer argumento.

K (no K5), 10 bytes

x@&1<#:'=x

Asume que la entrada está adentro x. ¡Pensé que sería divertido hacer una respuesta que no sea K5!

Perl 6, 16 bytes

Suponiendo que la lista esté almacenada $_, puede usar cualquiera de los siguientes fragmentos.
_{^{(que fue permitido específicamente)}}

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

keys .Bag (-) .Set # 18 bytes

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

Si no le importa que obtenga una bolsa, puede dejarla keys .

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

Ninguno de estos tiene la limitación de trabajar solo con enteros con signo, o incluso solo números para el caso.

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

En el interactivo Ruby Shell :

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

^{Guardado 2 bytes gracias a Kirill L.}

JavaScript, 35 28 bytes

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

¡Pruébelo en línea!

Después de publicar esto, me di cuenta de que era muy similar a la solución de w0lf .

Lisp común, 57 bytes

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

Octava, 33 bytes

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

• Encuentra los índices de la primera aparición de cada entero único,
• elimina esas ocurrencias, y
• encuentra los elementos únicos de la matriz restante.

Aquí está en ideone . He incluido el fragmento en una función para poder llamarlo utilizando todas las entradas de muestra.

Java 8, 80 bytes

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

Suponiendo que x contiene la Lista de números de entrada.

PHP, 35 37 bytes

Muy claro:

array_diff_key($a,array_unique($a))

Como nota: no agregué el ;al final de la línea, como dice la pregunta:

Su respuesta puede ser un fragmento que asume que la entrada se almacena en una variable (d, digamos) y se evalúa con el resultado correcto

Por lo tanto, este fragmento podría usarse así y se evalúa con el resultado correcto:

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

Otra nota

El código anterior funciona para todos los casos de prueba proporcionados en el desafío. En esos todos los caracteres no únicos son, como máximo, duplicados. Si un elemento puede aparecer más de dos veces, array_unique()sería necesario otro , que aumenta la longitud a 49 bytes :

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

Ediciones

• Se guardaron 2 bytes al reemplazar array_diff_assoccon array_diff_key. Gracias a Jörg Hülsermann .