Schreiben Sie ein Programm, das die nicht eindeutigen Elemente eines Arrays von Ganzzahlen mit Vorzeichen findet. Das resultierende Array kann in beliebiger Reihenfolge vorliegen.

Ihre Antwort kann ein Ausschnitt sein, der davon ausgeht, dass die Eingabe in einer Variablen gespeichert ist (z d. B.) und zum richtigen Ergebnis ausgewertet wird.

Testfälle

Jeder Testfall ist eine einzelne Zeile im Format input => output. Beachten Sie, dass auch andere Permutationen der Ausgabe gültig sind.

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

Die Reihenfolge der Elemente spielt keine Rolle.

Dies ist Codegolf, daher gewinnt die kürzeste Antwort (in Bytes).

K5 , 5 Bytes

Angenommen, die Eingabe befindet sich bereits in einer Variablen mit dem Namen d,

?d^?d

Nehmen Sie die verschiedenen Elemente ( ?) von d mit Ausnahme ( d^) der verschiedenen Elemente von d ( ?d). Schön symmetrisch, nein? Das funktioniert , weil die „außer“ Bediener entnimmt nur das erste Vorkommen des rechten Arguments vom linken Argumente.

Allgemeiner,

nu: {?x^?x}

In Aktion:

  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)

Bearbeiten:

Wenn wir die Reihenfolge beibehalten möchten, in der nicht eindeutige Elemente zum ersten Mal vorkommen, können wir die Quellliste umkehren, bevor und nachdem wir die eindeutigen Elemente über entfernen, mit Ausnahme der Kosten für 4 zusätzliche Bytes:

  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

Angenommen, das Array befindet sich bereits in Variable D (basierend auf diesem Kommentar ):

D{De=(},_&

Probieren Sie es online aus

Erläuterung:

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

Hinweis: Fügen Sie ein an, pwenn Sie einen hübschen Ausdruck wünschen. Andernfalls wird das resultierende Array standardmäßig nur ohne Begrenzer ausgedruckt. Dies ist akzeptabel, da in der Frage angegeben ist, dass das Snippet nur "zum richtigen Ergebnis auswerten" muss.

Standard Ein- / Ausgabeversion, 13:

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

Probieren Sie es online aus

Erläuterung:

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

Ziemlich kurz, auch beim Import. a \\ bentfernt das erste Auftreten eines jeden Elements baus a, und nubmacht alle Elemente einer Liste einzigartig.

Pyth, 7 Bytes

S{.-Q{Q

Probieren Sie es online aus.

Wie es funktioniert

Pyth speichert die ausgewerteten Eingaben automatisch in Qund druckt alle nicht verwendeten Rückgabewerte.

     {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

Ich hoffe, es ist in Ordnung anzunehmen, dass die ganzen Zahlen in Tabelle D gespeichert sind. Dies funktioniert sowohl in SQLServer, PostgreSQL und möglicherweise anderen. Danke an @manatwork aus den 2 Bytes.

Mathematica, 29 26 Bytes

Angenommen, die Eingabe wird gespeichert in d:

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

Ansonsten sind es 29 Bytes als unbenannte Funktion:

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

Hier ist d⋃d(oder #⋃#) ein Golf-Trick, um Duplikate zu entfernen - indem Mathematica die Mengenvereinigung mit sich selbst nimmt, interpretiert sie die Liste als eine Menge und entfernt Duplikate automatisch, während die tatsächliche Vereinigung nichts tut.

Anschließend filtern beide Methoden einfach die Elemente, die in der ursprünglichen Liste mindestens zweimal vorkommen.

JavaScript (ES6), 37 Byte

Führen Sie dies in der JavaScript-Konsole aus:

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

Matlab / Octave, 40

Ich gehe davon aus, dass Eingabewerte real sind (nicht komplex). Die Eingabe erfolgt in einer Variablen d.

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

Probieren Sie es online in Octave.

Python 3.5, 30

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

Verwendet das Auspacken von Python 3.5-Sets. Der ~-subtrahiert 1, was von 1 bis 0 zählt, was Falsy ist.

Dies gibt eine Liste. Wenn es in Ordnung ist, ein Set anzugeben, verwenden wir ein Set-Verständnis, das 1 Zeichen spart und keine Version 3.5 benötigt:

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

PowerShell, 31 29 Bytes

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

Nimmt an, dass $ddas bereits besiedelt ist (wie angegeben) - zB $d=@(-34,0,1,-34,4,8,4).

Group-ObjectLeitet das Array in das Cmdlet, in dem ähnliche Elemente zusammengefasst und ein Objekt ausgespuckt werden, das im Wesentlichen ein Array von Arrays ist. Wir leiten das an einen Where-Object(den ?Operator) weiter, der Countmehr als eins hat (dh es gibt Duplikate), und geben die .Namedieser Elemente aus. Hat auch einen Nebenbonus, die ursprüngliche Bestellung beizubehalten.

_{Bearbeiten - zwei Bytes dank Danko Durbić gespeichert}

APL (Dyalog Unicode) , 13 9 Byte ^SBCS

Anonyme implizite Präfixfunktion.

∊(⊂1↓⊣¨)⌸

Probieren Sie es online!

(… Wenden Sie )⌸ für jedes eindeutige Element (linkes Argument) und die Indizes, in denen es vorkommt (rechtes Argument) die folgende implizite Funktion an:

 ⊣¨ jeweils eines der linken (das eindeutige Element) auf der rechten Seite (die Indizes)

 1↓ lass eins fallen

 ⊂ Einschließen (verhindert das Auffüllen mit Nullen, um eine nicht zackige Matrix zu erstellen)

∊ ϵ nlist (Abflachen)

Julia, 30 29 Bytes

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

d.==d'Erstellt eine symmetrische Matrix mit dem Wert i,jtrue, wenn d[i]==d[j]und false, wenn nicht. sumWenn Sie in einer Dimension mischen und dann 1 subtrahieren, wird Null erzeugt, wenn nur eines der Elemente vorhanden ist, und ungleich Null, wenn mehr als eins vorhanden ist. findRuft die Indizes der Nicht-Null-Elemente ab, die dann zum Indizieren des Arrays dselbst verwendet werden. ∪(union) verhält sich so, uniqueals würde man die Wiederholungen auf diese Weise entfernen.

Alte Lösung:

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

Einfach - für jeden Eintrag wird geprüft, ob mehr als ein Eintrag im Array vorhanden ist. Diejenigen, für die es mehr als einen gibt, werden von "filter" zurückgegeben, und dann ∪verhält sich (union) so, uniqueals ob die Wiederholungen auf diese Weise entfernt würden.

Hinweis: Hatte es ursprünglich als Funktion, aber mit question kann ein Array in einer Variablen gespeichert werden, für die ich ddie in der Frage vorgeschlagene Option ausgewählt habe .

Python 2.7, 36 42

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

edit : umgab den Ausdruck mit liste (..), um das in der Frage geforderte Format einzuhalten

Oktave, 22 Bytes

Basierend auf Luis Mendos Antwort .

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

R, 31 24 Bytes

Danke an flodel für die 7 Bytes.

Angenommen, die Eingabe ist bereits in d.

Code:

unique(d[duplicated(d)])

edit: es wird nun korrekt ausgegeben , wenn mehr als 2 Duplikate vorhanden sind, wie von aditsu angegeben .

Python 3 - 33 30 Bytes

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

Repl-Ausgabe dals Eingabe.

Mathematica, 31, 29

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

Pyth, 7 Bytes

ft/QT{Q

Erläuterung:

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.

Der Filter entfernt alle Elemente, die genau einmal vorkommen, aus der Elementmenge.

LINQ, 62 54 Bytes

Ein bisschen neu hier, aber hier geht nichts.

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

K (ok) , 7 Bytes

Lösung:

&1<#:'=

Probieren Sie es online!

Erläuterung:

&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

Testausgang:

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

Mathematica, 23 Bytes

Mit Eingaben gespeichert in d:

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

In Abhängigkeit von 24 Bytes:

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

zum Beispiel mit

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

gibt dies zurück:

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

(Das erste Element jeder Unterliste ist das Element, das zweite ist die Häufigkeit des Auftretens). Das Anwenden auf diese Liste Pick[#,#2>1]&@@@wandelt sie in

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

Und wo das zweite Argument von Pickevaluiert zum Trueersten Argument zurückgegeben wird.

K (nicht K5), 10 Bytes

x@&1<#:'=x

Angenommen, die Eingabe ist in x. Ich dachte, es würde Spaß machen, eine Nicht-K5-Antwort zu machen!

Perl 6, 16 Bytes

Angenommen, die Liste ist in gespeichert, können $_Sie einen der folgenden Ausschnitte verwenden.
_{^{(was ausdrücklich erlaubt war)}}

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

keys .Bag (-) .Set # 18 bytes

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

Wenn es Sie nicht interessiert, dass Sie eine Tasche bekommen, können Sie aufhören keys .

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

Keines davon hat die Einschränkung, nur mit vorzeichenbehafteten ganzen Zahlen oder auch nur mit Zahlen zu arbeiten.

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

In der interaktiven Ruby Shell :

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

^{2 Bytes gespart dank Kirill L.}

JavaScript, 35 28 Bytes

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

Probieren Sie es online!

Nachdem ich dies gepostet hatte , stellte ich fest, dass es der Lösung von w0lf sehr ähnlich war .

Common Lisp, 57 Bytes

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

Oktave, 33 Bytes

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

• Findet die Indizes des ersten Vorkommens jeder eindeutigen Ganzzahl,
• entfernt diese Vorkommen und
• findet die eindeutigen Elemente des verbleibenden Arrays.

Hier ist es auf ideone . Ich habe das Snippet in eine Funktion eingebunden, damit ich es mit allen Sample-Eingaben aufrufen kann.

Java 8, 80 Bytes

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

Angenommen, x enthält die eingegebene Liste der Zahlen.

PHP, 35 37 Bytes

Ziemlich einfach:

array_diff_key($a,array_unique($a))

Als Anmerkung: Ich habe das ;am Ende der Zeile nicht hinzugefügt , wie die Fragen besagen:

Ihre Antwort kann ein Ausschnitt sein, der davon ausgeht, dass die Eingabe in einer Variablen gespeichert ist (z. B. d) und das richtige Ergebnis ergibt

Dieses Snippet könnte also so verwendet werden und ergibt das richtige Ergebnis:

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

Noch ein Hinweis

Der obige Code funktioniert für alle in der Challenge bereitgestellten Testfälle. In diesen sind alle nicht eindeutigen Zeichen höchstens Duplikate. Wenn ein Element mehr als zweimal vorkommen kann, ist ein weiteres Element array_unique()erforderlich, wodurch die Länge auf 49 Byte erhöht wird :

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

Bearbeitungen

• Gespeicherte 2 Bytes durch den Austausch array_diff_assocmit array_diff_key. Vielen Dank an Jörg Hülsermann .