Écrivez un programme qui trouve les éléments non uniques d'un tableau d'entiers signés. Le tableau résultant peut être dans n'importe quel ordre.

Votre réponse peut être un extrait de code qui suppose que l'entrée est stockée dans une variable ( ddisons) et évalue le résultat correct.

Cas de test

Chaque scénario de test est une seule ligne au format input => output. Notez que d'autres permutations de la sortie sont également valables.

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

L'ordre des éléments n'a pas d'importance.

Il s'agit du code golf, donc la réponse la plus courte (en octets) l'emporte.

K5 , 5 octets

En supposant que l'entrée se trouve déjà dans une variable appelée d,

?d^?d

Prenez les éléments distincts ( ?) de d sauf ( d^) les éléments distincts de d ( ?d). Joliment symétrique, non? Cela fonctionne car l'opérateur "except" supprime uniquement la première occurrence de l'argument droit de l'argument gauche.

Plus généralement,

nu: {?x^?x}

En action:

  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)

Modifier:

Si nous voulions conserver l'ordre de la première occurrence des éléments non uniques, nous pourrions inverser la liste source avant et après avoir supprimé les éléments uniques via sauf au prix de 4 octets supplémentaires:

  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

En supposant que le tableau est déjà dans la variable D (sur la base de ce commentaire ):

D{De=(},_&

Essayez-le en ligne

Explication:

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

Remarque: ajoutez un p si vous voulez une jolie impression, sinon le tableau résultant est simplement imprimé sans délimiteur par défaut. Cela est acceptable car la question spécifie que l'extrait n'a besoin que d '"évaluer le résultat correct".

Version entrée / sortie standard, 13:

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

Essayez-le en ligne

Explication:

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

Assez court, même avec l'importation. a \\ bsupprime la première occurrence de chaque élément de bfrom aet nubrend tous les éléments d'une liste uniques.

Pyth, 7 octets

S{.-Q{Q

Essayez-le en ligne.

Comment ça marche

Pyth stocke automatiquement l'entrée évaluée dans Qet imprime toutes les valeurs de retour inutilisées.

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

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

J'espère qu'il est OK de supposer que les entiers sont stockés dans la table D? Cela fonctionnera à la fois dans SQLServer, PostgreSQL et éventuellement dans d'autres. Merci à @manatwork des 2 octets.

Mathematica, 29 26 octets

En supposant que l'entrée est stockée dans d:

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

Sinon, c'est 29 octets en tant que fonction sans nom:

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

Ici, d⋃d(ou #⋃#) est une astuce de golf pour supprimer les doublons - en prenant l'union définie avec lui-même, Mathematica interprète la liste comme un ensemble, supprimant automatiquement les doublons, tandis que l'union réelle ne fait rien.

Ensuite, les deux méthodes filtrent simplement les éléments qui apparaissent dans la liste d'origine au moins deux fois.

JavaScript (ES6), 37 octets

Exécutez ceci dans la console JavaScript:

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

Matlab / Octave, 40

Je suppose que les valeurs d'entrée sont réelles (pas complexes). L'entrée est dans une variable d.

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

Essayez-le en ligne dans Octave.

Python 3.5, 30

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

Utilise le déballage de l'ensemble de Python 3.5. le~- soustrait 1, ce qui prend un compte de 1 à 0, ce qui est Falsy.

Cela donne une liste. Si donner un ensemble est OK, alors nous utilisons une compréhension d'ensemble, sauvant 1 caractère et n'ayant pas besoin de la version 3.5:

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

PowerShell, 31 29 octets

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

En supposant que $ddéjà peuplé (comme indiqué) - par exemple $d=@(-34,0,1,-34,4,8,4).

Pipes le tableau dans l' Group-Objectapplet de commande, qui regroupe les éléments similaires et crache un objet qui est essentiellement un tableau de tableaux. Nous redirigeons cela vers un Where-Object(l' ?opérateur) qui en a Countplus d'un (c'est-à-dire qu'il y a des doublons), et sortons le .Namede ces éléments. A un bonus supplémentaire de préservation de la commande initiale.

_{Edit - sauvé deux octets grâce à Danko Durbić}

APL (Dyalog Unicode) , 13 9 octets ^SBCS

Fonction de préfixe tacite anonyme.

∊(⊂1↓⊣¨)⌸

Essayez-le en ligne!

(… )⌸ Pour chaque élément unique (argument de gauche) et les indices où il se produit (argument de droite), appliquez la fonction tacite suivante:

 ⊣¨ l'un de gauche (l'élément unique) pour chacun à droite (les indices)

 1↓ en déposer un

 ⊂ entourer (empêche le remplissage avec des zéros pour créer une matrice non irrégulière)

∊ ϵ nlist (aplatir)

Julia, 30 29 octets

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

d.==d'crée une matrice symétrique dont la valeur i,jest true si d[i]==d[j]et false sinon. summing dans une dimension, puis soustraire 1 produira zéro s'il n'y a qu'un seul élément et différent de zéro s'il y en a plus d'un.findobtiendra les index des éléments non nuls, qui sont ensuite utilisés pour indexer le tableau dlui-même. ∪(union) agit comme uniques'il était utilisé de cette manière, supprimant les répétitions.

Ancienne solution:

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

Simple - pour chaque entrée, il vérifie s'il y en a plusieurs dans le tableau. Celles pour lesquelles il y en a plusieurs sont renvoyées par "filtre", puis∪ (union) agit commeunique lorsqu'il est utilisé de cette manière, supprimant les répétitions.

Remarque: à l'origine, il s'agissait d'une fonction, mais la question permet au tableau d'être stocké dans une variable, pour laquelle j'ai choisi dcomme suggéré dans la question.

Python 2.7, 36 42

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

modifier : entourer l'expression de liste (..) afin de respecter le format requis dans la question

Octave, 22 octets

Basé sur la réponse de Luis Mendo .

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

R, 31 24 octets

Merci à flodel pour les 7 octets.

En supposant que l'entrée est déjà en d.

code:

unique(d[duplicated(d)])

edit: maintenant il sort correctement s'il y a plus de 2 doublons comme indiqué par aditsu .

Python 3-33 30 octets

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

Repl sortie, dcomme entrée.

Mathematica, 31 29

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

Pyth, 7 octets

ft/QT{Q

Explication:

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.

Le filtre supprime tous les éléments qui apparaissent exactement une fois dans l'ensemble d'éléments.

LINQ, 62 54 octets

Un peu nouveau ici, mais ici ne va rien.

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

K (oK) , 7 octets

Solution:

&1<#:'=

Essayez-le en ligne!

Explication:

&1<#:'= / the solution
      = / group, key => value (index)
   #:'  / count length of each group
 1<     / 1 less than 
&       / keys where true

Coquille + coreutils GNU, 12

sort|uniq -d

Sortie de test:

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

Mathematica, 23 octets

Avec une entrée stockée dans d:

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

En fonction, 24 octets:

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

par exemple, avec

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

renvoie ceci:

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

(le premier élément de chaque sous-liste est l'élément, le second est la fréquence d'occurrence). L'application à cette liste la Pick[#,#2>1]&@@@transforme en

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

Et où le deuxième argument de Picks'évalue au Truepremier argument est retourné.

K (pas K5), 10 octets

x@&1<#:'=x

Suppose que l'entrée est en x. Je pensais que ce serait amusant de faire une réponse non K5!

Perl 6, 16 octets

En supposant que la liste est stockée dans, $_vous pouvez utiliser l'un des extraits suivants.
_{^{(ce qui était spécifiquement autorisé)}}

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

keys .Bag (-) .Set # 18 bytes

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

Si vous ne vous souciez pas que vous obtenez un sac, vous pouvez laisser de côté keys .

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

Aucun de ceux-ci n'a la limitation de travailler uniquement sur des entiers signés, ou même seulement des nombres d'ailleurs.

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

Rubis, 30 28 octets

Dans l'Interactive Ruby Shell :

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

^{Enregistré 2 octets grâce à Kirill L.}

JavaScript, 35 28 octets

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

Essayez-le en ligne!

Après avoir posté cela, j'ai réalisé que c'était très similaire à la solution de w0lf .

Lisp commun, 57 octets

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

Octave, 33 octets

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

• Trouve les indices de la première occurrence de chaque entier unique,
• supprime ces occurrences, et
• trouve les éléments uniques du tableau restant.

Ici, c'est sur ideone . J'ai enveloppé l'extrait de code dans une fonction afin que je puisse l'appeler en utilisant toutes les entrées d'échantillon.

Java 8, 80 octets

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

En supposant que x contient la liste de nombres entrée.

PHP, 35 37 octets

Assez simple:

array_diff_key($a,array_unique($a))

Remarque: je n'ai pas ajouté le ;à la fin de la ligne, comme l'indique la question:

Votre réponse peut être un extrait qui suppose que l'entrée est stockée dans une variable (d, disons) et évalue le résultat correct

Cet extrait peut donc être utilisé comme ceci et évalue le résultat correct:

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

Une autre note

Le code ci-dessus fonctionne pour tous les cas de test fournis dans le défi. Dans ceux-ci, tous les caractères non uniques sont tout au plus des doublons. Si un élément peut se produire plus de deux fois, un autre array_unique()serait nécessaire, ce qui augmentera la longueur à 49 octets :

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

Modifications

• Enregistré 2 octets en remplaçant array_diff_assocpar array_diff_key. Merci à Jörg Hülsermann .