Éléments non uniques


24

É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.



1
puisque c'est pour un tableau d'entiers, le code serait différent. Je pense beaucoup plus court. C'est pour une chaîne.
garg10mai

1
Sommes-nous autorisés à accepter les entrées sous forme de lignes plutôt que sous forme de tableau? Par exemple, au lieu de [-1, 0, 1], peut - on l' entrée (remplacer \ n avec sauts de ligne): "-1\n0\n1"?
Addison Crump

1
La sortie doit-elle être une liste ou un ensemble est-il acceptable?
Dennis

Et doit-il sortir dans ce format?
Addison Crump

Réponses:


16

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)

10

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

1
13:q~$e`{((<~}%p
Sp3000

3
@ Sp3000 J'ai trouvé une autre version de 13 octets avant de lire votre commentaire :) Il préserve également l'ordre.
aditsu

9

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.


7

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.

7

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.


En supposant que i est le seul champ du tableau d, dans PostgreSQL, vous pouvez le réduire à select*from d group by 1having count(*)>1. (L'analyseur MySQL et SQLite gérera également la select*frompartie non séparée , mais ils ne comprennent pas 1having.)
manatwork

@manatwork applaudit pour cela, le serveur sql comprend également le select*from. N'aime pas le 1havingbien .. laissera cela commeI having
MickyT

6

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.


6

JavaScript (ES6), 37 octets

Exécutez ceci dans la console JavaScript:

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

Il est généralement admis que JavaScript a besoin d'une sorte explicite fonction « sortie / print » ( par exemple console.log, alertetc.) soit considérée comme complète. Si un défi dit "écrire un programme ou une fonction", alors la fonction renvoie aussi suffit. A part ça, solution très efficace!
Mwr247

1
@ Mwr247 La question indique que la réponse peut être un extrait qui évalue le résultat correct .
Cristian Lupascu

1
Il semble que j'ai mal interprété ce paragraphe. Excuses alors =)
Mwr247

@ Mwr247 Pas de problème! :)
Cristian Lupascu

6

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.


Pas besoin de saisir, vous pouvez supposer les données dans la variable 'd'
garg10mai

1
@ garg10may Merci. Mis à jour. Vous devez préciser que dans votre message
Luis Mendo

La sortie est incorrecte quand d = [3, 0, 0, 1, 1, 0, 5, 3]. Il y a deux 0art.
alephalpha

@alephalpha Merci! corrigé (8 octets de plus)
Luis Mendo

Shorter: d(sum(triu(bsxfun(@eq,d,d')))==2). Ou en Octave:d(sum(triu(d==d'))==2)
alephalpha

6

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)}

SyntaxError: invalid syntaxpour Python 3 est-il valable uniquement pour 3.5? Quand le python a-t-il commencé à devenir ésotérique.
garg10mai

@ garg10may Attendez juste de voir ce que 3.6 a en magasin ...
Sp3000

1
@ Sp3000 Awesome. Ressemble à la même configuration que Scala. Infiniment plus lisible que plus d'alternatives.
Carcigenicate

6

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ć


1
Je pense que vous pouvez remplacer $_.Count-gt1par ce $_.Count-1qui serait vrai pour tout Countplus d'un.
Danko Durbić

@ DankoDurbić Excellent!
AdmBorkBork

6

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)


5

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.


5

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


cela ne produira pas une liste
garg10may

Dois-je donc entourer mon extrait d'un appel à la liste (...)?
dieter

Oui, la sortie doit être un tableau uniquement.
garg10mai


5

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 .


2
C'est magnifique! Mais le 4ème cas de test ne semble pas être correct ...
aditsu

1
Vous pouvez supprimer whichcar [accepte également un argument logique.
flodel

5

Python 3-33 30 octets

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

Repl sortie, dcomme entrée.



4

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.


4

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)

Bienvenue sur le site! Je ne connais pas LINQ, mais il y a des espaces que vous pouvez probablement supprimer pour améliorer votre score.
DLosc

4

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

3

Coquille + coreutils GNU, 12

sort|uniq -d

Sortie de test:

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

3

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é.


3

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!


3

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)



2

Lisp commun, 57 octets

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

2

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.


2

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.


2

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 .

1
array_diff_keyà la placearray_diff_assoc
Jörg Hülsermann

@ JörgHülsermann Bonne prise. Merci. Jetons un coup d'œil à vos autres suggestions dans les prochains jours.
insertusernamehere
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.