Operationen (Vereinigung, Schnittmenge) für das Swift-Array festlegen?

Gibt es Standardbibliotheksaufrufe, mit denen ich entweder Set-Operationen für zwei Arrays ausführen oder diese Logik selbst implementieren kann (idealerweise so funktional und auch effizient wie möglich)?

Ja, Swift hat die SetKlasse.

let array1 = ["a", "b", "c"]
let array2 = ["a", "b", "d"]

let set1:Set<String> = Set(array1)
let set2:Set<String> = Set(array2)

Swift 3.0+ kann Operationen an Sets ausführen als:

firstSet.union(secondSet)// Union of two sets
firstSet.intersection(secondSet)// Intersection of two sets
firstSet.symmetricDifference(secondSet)// exclusiveOr

Swift 2.0 kann mit Array-Argumenten rechnen:

set1.union(array2)       // {"a", "b", "c", "d"} 
set1.intersect(array2)   // {"a", "b"}
set1.subtract(array2)    // {"c"}
set1.exclusiveOr(array2) // {"c", "d"}

Swift 1.2+ kann auf Sätzen rechnen:

set1.union(set2)        // {"a", "b", "c", "d"}
set1.intersect(set2)    // {"a", "b"}
set1.subtract(set2)     // {"c"}
set1.exclusiveOr(set2)  // {"c", "d"}

Wenn Sie benutzerdefinierte Strukturen verwenden, müssen Sie Hashable implementieren.

Vielen Dank an Michael Stern in den Kommentaren zum Swift 2.0 Update.

Vielen Dank an Amjad Husseini in den Kommentaren für die Hashable-Info.

Es gibt keine Standardbibliotheksaufrufe, aber Sie können sich die ExSwift- Bibliothek ansehen . Es enthält eine Reihe neuer Funktionen für Arrays, einschließlich Differenz, Schnittmenge und Vereinigung.

Möglicherweise möchten Sie dem gleichen Muster wie in Objective-C folgen, in dem auch solche Operationen fehlen, aber es gibt eine einfache Problemumgehung:

Wie schneide ich zwei Arrays in Ziel C?

Die effizienteste Methode, die ich kenne, ist die Verwendung von Gödelnummern. Google für Godel-Codierung.

Die Idee ist so. Angenommen, Sie haben N mögliche Zahlen und müssen Sätze daraus erstellen. Zum Beispiel ist N = 100.000 und möchte Mengen wie {1,2,3}, {5, 88, 19000} usw. erstellen.

Die Idee ist, die Liste der N Primzahlen im Speicher zu behalten und für eine gegebene Menge {a, b, c, ...} als zu codieren

 prime[a]*prime[b]*prime[c]*...

Sie codieren also einen Satz als BigNumber. Die Operationen mit BigNumbers sind immer noch sehr schnell, obwohl sie langsamer sind als Operationen mit Ganzzahlen.

Um 2 Sätze A, B zu vereinen, nehmen Sie

  UNITE(A, B) = lcm(a, b)

Das niedrigste gemeinsame Vielfache von A und B als A und B sind Mengen und beide Zahlen.

Um die Kreuzung zu machen, nehmen Sie

 INTERSECT(A, B) = gcd (a, b)

größter gemeinsamer Teiler.

und so weiter.

Diese Codierung wird als Godelisierung bezeichnet. Sie können nach mehr googeln. Die gesamte Sprache der Arithmetik, die mit der Logik von Frege geschrieben wurde, kann auf diese Weise mit Zahlen codiert werden.

Um die Operation zu bekommen, ist-Mitglied? es ist sehr einfach --

ISMEMBER(x, S) = remainder(s,x)==0

Um den Kardinal zu bekommen, ist es etwas komplizierter -

CARDINAL(S) = # of prime factors in s

Sie zerlegen die Zahl S, die die Menge der Primfaktoren darstellt, und addieren deren Exponenten. Falls die Menge keine Duplikate zulässt, haben Sie alle Exponenten 1.