Removing duplicate elements from an array in Swift

Question

I might have an array that looks like the following   1  4  2  2  6  24  15  2  60  15  6  Or  really  any sequence of like-typed portions of data  What I want to do is ensure that there is only one of each identical element  For example  the above array would become   1  4  2  6  24  15  60  Notice that the duplicates of 2  6  and 15 were removed to ensure that there was only one of each identical element  Does Swift provide a way to do this easily  or will I have to do it myself

User · Answer

For arrays where the elements are neither Hashable nor Comparable (e.g. complex objects, dictionaries or structs), this extension provides a generalized way to remove duplicates:

extension Array
{
   func filterDuplicate<T:Hashable>(_ keyValue:(Element)->T) -> [Element]
   {
      var uniqueKeys = Set<T>()
      return filter{uniqueKeys.insert(keyValue($0)).inserted}
   }

   func filterDuplicate<T>(_ keyValue:(Element)->T) -> [Element]
   { 
      return filterDuplicate{"\(keyValue($0))"}
   }
}

// example usage: (for a unique combination of attributes):

peopleArray = peopleArray.filterDuplicate{ ($0.name, $0.age, $0.sex) }

or...

peopleArray = peopleArray.filterDuplicate{ "\(($0.name, $0.age, $0.sex))" }

You don't have to bother with making values Hashable and it allows you to use different combinations of fields for uniqueness.

Note: for a more robust approach, please see the solution proposed by Coeur in the comments below.

stackoverflow.com/a/55684308/1033581

[EDIT] Swift 4 alternative

With Swift 4.2 you can use the Hasher class to build a hash much easier. The above extension could be changed to leverage this :

extension Array
{
    func filterDuplicate(_ keyValue:((AnyHashable...)->AnyHashable,Element)->AnyHashable) -> [Element]
    {
        func makeHash(_ params:AnyHashable ...) -> AnyHashable
        { 
           var hash = Hasher()
           params.forEach{ hash.combine($0) }
           return hash.finalize()
        }  
        var uniqueKeys = Set<AnyHashable>()
        return filter{uniqueKeys.insert(keyValue(makeHash,$0)).inserted}     
    }
}

The calling syntax is a little different because the closure receives an additional parameter containing a function to hash a variable number of values (which must be Hashable individually)

peopleArray = peopleArray.filterDuplicate{ $0($1.name, $1.age, $1.sex) }

It will also work with a single uniqueness value (using $1 and ignoring $0).

peopleArray = peopleArray.filterDuplicate{ $1.name }

User · Answer

An alternate  if not optimal  solution from here using immutable types rather than variables   func deleteDuplicates lt S  ExtensibleCollectionType where S Generator Element  Equatable gt  seq S - gt  S       let s   reduce seq  S             ac  x in contains ac x    ac   ac    x            return s     Included to contrast Jean-Pillippe s imperative approach with a functional approach   As a bonus this function works with strings as well as arrays   Edit  This answer was written in 2014 for Swift 1 0  before Set was available in Swift   It doesn t require Hashable conformance  amp  runs in quadratic time

User · Answer

Inspired by https   www swiftbysundell com posts the-power-of-key-paths-in-swift  we can declare a more powerful tool that is able to filter for unicity on any keyPath  Thanks to Alexander comments on various answers regarding complexity  the below solutions should be near optimal   Non-mutating solution  We extend with a function that is able to filter for unicity on any keyPath   extension RangeReplaceableCollection           Returns a collection containing  in order  the first instances of         elements of the sequence that compare equally for the keyPath      func unique lt T  Hashable gt  for keyPath  KeyPath lt Element  T gt   - gt  Self           var unique   Set lt T gt            return filter   unique insert  0 keyPath  keyPath   inserted             Note  in the case where your object doesn t conform to RangeReplaceableCollection  but does conform to Sequence  you can have this additional extension  but the return type will always be an Array   extension Sequence           Returns an array containing  in order  the first instances of         elements of the sequence that compare equally for the keyPath      func unique lt T  Hashable gt  for keyPath  KeyPath lt Element  T gt   - gt   Element            var unique   Set lt T gt            return filter   unique insert  0 keyPath  keyPath   inserted             Usage  If we want unicity for elements themselves  as in the question  we use the keyPath   self   let a    1  4  2  2  6  24  15  2  60  15  6  let b   a unique for    self     b is  1  4  2  6  24  15  60       If we want unicity for something else  like for the id of a collection of objects  then we use the keyPath of our choice   let a    CGPoint x  1  y  1   CGPoint x  2  y  1   CGPoint x  1  y  2   let b   a unique for    y     b is   x 1 y 1    x 1 y 2          Mutating solution  We extend with a mutating function that is able to filter for unicity on any keyPath   extension RangeReplaceableCollection           Keeps only  in order  the first instances of         elements of the collection that compare equally for the keyPath      mutating func uniqueInPlace lt T  Hashable gt  for keyPath  KeyPath lt Element  T gt             var unique   Set lt T gt            removeAll    unique insert  0 keyPath  keyPath   inserted             Usage  If we want unicity for elements themselves  as in the question  we use the keyPath   self   var a    1  4  2  2  6  24  15  2  60  15  6  a uniqueInPlace for    self     a is  1  4  2  6  24  15  60       If we want unicity for something else  like for the id of a collection of objects  then we use the keyPath of our choice   var a    CGPoint x  1  y  1   CGPoint x  2  y  1   CGPoint x  1  y  2   a uniqueInPlace for    y     a is   x 1 y 1    x 1 y 2

User · Answer

edit update Swift 4 or later  We can also extend RangeReplaceableCollection protocol to allow it to be used with StringProtocol types as well   extension RangeReplaceableCollection where Element  Hashable       var orderedSet  Self           var set   Set lt Element gt            return filter   set insert  0  inserted             mutating func removeDuplicates             var set   Set lt Element gt            removeAll    set insert  0  inserted               let integers    1  4  2  2  6  24  15  2  60  15  6  let integersOrderedSet   integers orderedSet     1  4  2  6  24  15  60       abcdefabcghi  orderedSet      abcdefghi   abcdefabcghi  dropFirst 3  orderedSet     defabcghi      Mutating method   var string    abcdefabcghi  string removeDuplicates    string       abcdefghi   var substring    abcdefabcdefghi  dropFirst 3       defabcdefghi  substring removeDuplicates   substring       defabcghi      For Swift 3 click here

User · Answer

The easiest way would be to use NSOrderedSet  that stores unique elements and preserves the elements order  Like   func removeDuplicates from items   Int   - gt   Int        let uniqueItems   NSOrderedSet array  items      return  uniqueItems array as   Int            let arr    1  4  2  2  6  24  15  2  60  15  6  removeDuplicates from  arr

User · Answer

Xcode 10 1 - Swift 4 2 Simple and Powerful Solution  func removeDuplicates   nums  inout  Int   - gt  Int       nums   Set nums  sorted       return nums count     Example  var arr    1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9  removeDuplicates  amp arr   print arr      1 2 3 4 5 6 7 8 9

User · Answer

Here s a category on SequenceType which preserves the original order of the array  but uses a Set to do the contains lookups to avoid the O n  cost on Array s contains     method   public extension Sequence where Element  Hashable            Return the sequence with all duplicates removed                  i e     1  2  3  1  2   uniqued        1  2  3                    - note  Taken from stackoverflow com a 46354989 3141234  as                  per  Alexander s comment      func uniqued   - gt   Element            var seen   Set lt Element gt            return self filter   seen insert  0  inserted             If you aren t Hashable or Equatable  you can pass in a predicate to do the equality check   extension Sequence            Return the sequence with all duplicates removed                  Duplicate  in this case  is defined as returning  true  from  comparator                   - note  Taken from stackoverflow com a 46354989 3141234     func uniqued comparator   escaping  Element  Element  throws - gt  Bool  rethrows - gt   Element            var buffer   Element                for element in self                  If element is already in buffer  skip to the next element             if try buffer contains where    try comparator element   0                       continue                            buffer append element                     return buffer           Now  if you don t have Hashable  but are Equatable  you can use this method   extension Sequence where Element  Equatable            Return the sequence with all duplicates removed                  i e     1  2  3  1  2   uniqued        1  2  3                    - note  Taken from stackoverflow com a 46354989 3141234     func uniqued   - gt   Element            return self uniqued comparator                Finally  you can add a key path version of uniqued like this   extension Sequence            Returns the sequence with duplicate elements removed  performing the comparison usinig the property at         the supplied keypath                  i e                                          MyStruct value   Hello              MyStruct value   Hello              MyStruct value   World              uniqued   value                      would result in                                         MyStruct value   Hello              MyStruct value   World                                         - note  Taken from stackoverflow com a 46354989 3141234             func uniqued lt T  Equatable gt    keyPath  KeyPath lt Element  T gt   - gt   Element            self uniqued    0 keyPath  keyPath      1 keyPath  keyPath              You can stick both of these into your app  Swift will choose the right one depending on your sequence s Iterator Element type

User · Answer

Swift 4  Guaranteed to keep ordering   extension Array where Element  Equatable       func removingDuplicates   - gt  Array           return reduce into        result  element in             if  result contains element                    result append element

User · Answer

In case you need values sorted  this works  Swift 4   let sortedValues   Array Set array   sorted

User · Answer

if you want to keep the order as well then use this let fruits     quot apple quot    quot pear quot    quot pear quot    quot banana quot    quot apple quot    let orderedNoDuplicates   Array NSOrderedSet array  fruits  map    0 as  String

User · Answer

My solution  it seems it can be in O n  time as Hash map access is O 1   and filter is O n   It also uses by closure to select property by which to make the distinction of elements in sequence    extension Sequence        func distinct lt T  Hashable gt  by   Element  - gt  T  - gt   Element            var seen   T  Bool                return self filter   seen updateValue true  forKey  by  0      nil

User · Answer

this is the simplest way in swift 4 2 onwards the code like below  let keyarray NSMutableArray   NSMutableArray    for  object in dataArr       if  keysArray contains object           keysArray add object           print keysArray

User · Answer

I have created a higher-order function that has time complexity is o n   Also  capability like the map to return any type you want     extension Sequence       func distinct lt T U gt    provider   Element  - gt   U  T   - gt   T  where U  Hashable           var uniqueKeys   Set lt U gt            var distintValues    T            for object in self               let transformed   provider object              if  uniqueKeys contains transformed 0                    distintValues append transformed 1                  uniqueKeys insert transformed 0                                  return distintValues

User · Answer

You can convert to a Set and back to an Array again quite easily  let unique   Array Set originals    This is not guaranteed to maintain the original order of the array

User · Answer

I ve made a simple-as-possible extension for that purpose   extension Array where Element  Equatable        func containsHowMany   elem  Element  - gt  Int           return reduce 0     1    elem    0   1    0              func duplicatesRemoved   - gt  Array           return self filter   self containsHowMany  0     1              mutating func removeDuplicates             self   self duplicatesRemoved              You can use duplicatesRemoved   to get a new array  whose duplicate elements are removed  or removeDuplicates   to mutate itself  See   let arr    1  1  1  2  2  3  4  5  6  6  6  6  6  7  8   let noDuplicates   arr duplicatesRemoved   print arr      1  1  1  2  2  3  4  5  6  6  6  6  6  7  8  print noDuplicates      1  2  3  4  5  6  7  8   arr removeDuplicates   print arr      1  2  3  4  5  6  7  8

User · Answer

This works in Swift 4  if you do not want need to convert the result to an Array  but can do with a Set  The result is not sorted by default  but you can do that with sorted    which returns an array  as shown in the print statement    let array    1  4  2  2  6  24  15  2  60  15  6   var result   Set lt Int gt        array map  result insert  0     print result sorted         1  2  4  6  15  24  60

User · Answer

var numbers    1 2 3 4 5 10 10  12  12  6 6 6 7 8 8  8  8  8   7   1   1  2   9   var newArr    Int       for n in numbers       if  newArr contains n            newArr append n           output -  1  2  3  4  5  10  12  6  7  8  9  The above solution maintains order but very slow as  contains iterates again and again  Thus use the ordered set  This will print the ordered array  Array NSOrderedSet init array  numbers    output -  1  2  3  4  5  10  12  6  7  8  9  This Will Print an unordered array  let uniqueUnordered   Array Set numbers    output -  4  2  1  9  10  3  5  6  8  12  7

User · Answer

You can always use a Dictionary  because a Dictionary can only hold unique values  For example   var arrayOfDates  NSArray     15 04 01   15 04 01   15 04 02   15 04 02   15 04 03   15 04 03   15 04 03    var datesOnlyDict   NSMutableDictionary   var x   Int    for  x 0 x lt  arrayOfDates count  x          let date   arrayOfDates x  as String     datesOnlyDict setValue  foo   forKey  date     let uniqueDatesArray  NSArray   datesOnlyDict allKeys    uniqueDatesArray     15 04 01    15 04 03    15 04 02    println uniqueDatesArray count        3   As you can see  the resulting array will not always be in  order   If you wish to sort order the Array  add this   var sortedArray   sorted datesOnlyArray     obj1  obj2  in      let p1   obj1 as String     let p2   obj2 as String     return p1  lt  p2    println sortedArray         15 04 01    15 04 02    15 04 03

User · Answer

swift 2  with uniq function  answer   func uniq lt S  SequenceType  E  Hashable where E  S Generator Element gt  source  S  - gt   E        var seen   E Bool            return source filter    v  - gt  Bool in         return seen updateValue true  forKey  v     nil            use   var test    1 2 3 4 5 6 7 8 9 9 9 9 9 9  print uniq test     1 2 3 4 5 6 7 8 9

User · Answer

I used  Jean-Philippe Pellet s answer and made an Array extension that does set-like operations on arrays  while maintaining the order of elements       Extensions for performing set-like operations on lists  maintaining order extension Array where Element  Hashable     func unique   - gt   Element        var seen   Element Bool            return self filter   seen updateValue true  forKey   0     nil           func subtract takeAway   Element   - gt   Element        let set   Set takeAway      return self filter    set contains  0            func intersect with   Element   - gt   Element        let set   Set with      return self filter   set contains  0

User · Answer

Use a Set or NSOrderedSet to remove duplicates  then convert back to an Array  let uniqueUnordered   Array Set array   let uniqueOrdered   Array NSOrderedSet array  array

User · Answer

First add all the elements of an array to NSOrderedSet  This will remove all the duplicates in your array  Again convert this orderedset to an array    Done       Example  let array    1 1 1 1 2 2 2 2 4 6 8   let orderedSet   NSOrderedSet   NSOrderedSet array  array   let arrayWithoutDuplicates   NSArray   orderedSet array as NSArray   output of arrayWithoutDuplicates -  1 2 4 6 8

User · Answer

Swift 3  Swift 4  Swift 5  Just one line code to omit Array duplicates without effecting order   let filteredArr   Array NSOrderedSet array  yourArray

User · Answer

Many answers available here  but I missed this simple extension  suitable for Swift 2 and up   extension Array where Element Equatable       func removeDuplicates   - gt   Element            var result    Element             for value in self               if result contains value     false                   result append value                                   return result           Makes it super simple  Can be called like this   let arrayOfInts    2  2  4  4  print arrayOfInts removeDuplicates       Prints   2  4    Filtering based on properties  To filter an array based on properties  you can use this method   extension Array        func filterDuplicates  noescape includeElement   lhs Element  rhs Element  - gt  Bool  - gt   Element           var results    Element             forEach    element  in             let existingElements   results filter                   return includeElement lhs  element  rhs   0                            if existingElements count    0                   results append element                                   return results           Which you can call as followed   let filteredElements   myElements filterDuplicates    0 PropertyOne     1 PropertyOne  amp  amp   0 PropertyTwo     1 PropertyTwo

User · Answer

One more Swift 3 0 solution to remove duplicates from an array  This solution improves on many other solutions already proposed by    Preserving the order of the elements in the input array Linear complexity O n   single pass filter O n    set insertion O 1    Given the integer array   let numberArray    10  1  2  3  2  1  15  4  5  6  7  3  2  12  2  5  5  6  10  7  8  3  3  45  5  15  6  7  8  7    Functional code   func orderedSet lt T  Hashable gt  array  Array lt T gt   - gt  Array lt T gt        var unique   Set lt T gt        return array filter   element in         return unique insert element  inserted          orderedSet array  numberArray       10  1  2  3  15  4  5  6  7  12  8  45    Array extension code    extension Array where Element Hashable       var orderedSet  Array           var unique   Set lt Element gt            return filter   element in             return unique insert element  inserted                    numberArray orderedSet     10  1  2  3  15  4  5  6  7  12  8  45    This code takes advantage of the result returned by the insert operation on Set  which executes on O 1   and returns a tuple indicating if the item was inserted or if it already existed in the set   If the item was in the set  filter will exclude it from the final result

User · Answer

Swift 4  public extension Array where Element  Hashable       func uniqued   - gt   Element            var seen   Set lt Element gt            return filter  seen insert  0  inserted               every attempt to insert will also return a tuple   inserted  Bool  memberAfterInsert  Set Element   See documentation    Using the returned value helps us to avoid looping or doing any other operation

User · Answer

In Swift 5   var array   String       Aman    Sumit    Aman    Sumit    Mohan    Mohan    Amit     let uniq   Array Set array    print uniq    Output Will be     Sumit    Mohan    Amit    Aman

User · Answer

Think like a functional programmer     To filter the list based on whether the element has already occurred  you need the index  You can use enumerated to get the index and map to return to the list of values   let unique   myArray      enumerated        filter  myArray firstIndex of   0 1      0 0        map   0 1     This guarantees the order  If you don t mind about the order then the existing answer of Array Set myArray   is simpler and probably more efficient     UPDATE  Some notes on efficiency and correctness  A few people have commented on the efficiency  I m definitely in the school of writing correct and simple code first and then figuring out bottlenecks later  though I appreciate it s debatable whether this is clearer than Array Set array     This method is a lot slower than Array Set array    As noted in comments  it does preserve order and works on elements that aren t Hashable   However   Alain T s method also preserves order and is also a lot faster  So unless your element type is not hashable  or you just need a quick one liner  then I d suggest going with their solution   Here are a few tests on a MacBook Pro  2014  on Xcode 11 3 1  Swift 5 1  in Release mode   The profiler function and two methods to compare   func printTimeElapsed title String  operation   - gt           var totalTime   0 0     for   in  0   lt 1000            let startTime   CFAbsoluteTimeGetCurrent           operation           let timeElapsed   CFAbsoluteTimeGetCurrent   - startTime         totalTime    timeElapsed           let meanTime   totalTime   1000     print  Mean time for   title     meanTime  s      func method1 lt T  Hashable gt    array  Array lt T gt   - gt  Array lt T gt        return Array Set array      func method2 lt T  Equatable gt    array  Array lt T gt   - gt  Array lt T gt       return array      enumerated        filter  array firstIndex of   0 1      0 0        map   0 1         Alain T  s answer  adapted  func method3 lt T  Hashable gt    array  Array lt T gt   - gt  Array lt T gt        var uniqueKeys   Set lt T gt        return array filter uniqueKeys insert  0  inserted      And a small variety of test inputs   func randomString   length  Int  - gt  String     let letters    abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789    return String  0   lt length  map    in letters randomElement          let shortIntList    0   lt 100  map   in Int random in  0   lt 100    let longIntList    0   lt 10000  map   in Int random in  0   lt 10000    let longIntListManyRepetitions    0   lt 10000  map   in Int random in  0   lt 100    let longStringList    0   lt 10000  map   in randomString 1000   let longMegaStringList    0   lt 10000  map   in randomString 10000     Gives as output   Mean time for method1 on shortIntList  2 7358531951904296e-06 s Mean time for method2 on shortIntList  4 910230636596679e-06 s Mean time for method3 on shortIntList  6 417632102966309e-06 s Mean time for method1 on longIntList  0 0002518167495727539 s Mean time for method2 on longIntList  0 021718120217323302 s Mean time for method3 on longIntList  0 0005312927961349487 s Mean time for method1 on longIntListManyRepetitions  0 00014377200603485108 s Mean time for method2 on longIntListManyRepetitions  0 0007293639183044434 s Mean time for method3 on longIntListManyRepetitions  0 0001843773126602173 s Mean time for method1 on longStringList  0 007168249964714051 s Mean time for method2 on longStringList  0 9114790915250778 s Mean time for method3 on longStringList  0 015888616919517515 s Mean time for method1 on longMegaStringList  0 0525397013425827 s Mean time for method2 on longMegaStringList  1 111266262292862 s Mean time for method3 on longMegaStringList  0 11214958941936493 s

User · Answer

Let me suggest an answer similar to Scott Gardner s answer but with more laconic syntax using reduce  This solution removes duplicates from an array of custom objects  keeping the initial order      Custom Struct  Can be also class      Need to be  equitable  in order to use  contains  method below struct CustomStruct   Equatable         let name  String       let lastName   String           conform to Equatable protocol  feel free to change the logic of  equality  func    lhs  CustomStruct  rhs  CustomStruct  - gt  Bool     return  lhs name    rhs name  amp  amp  lhs lastName    rhs lastName     let categories    CustomStruct name   name1   lastName   lastName1                      CustomStruct name   name2   lastName   lastName1                      CustomStruct name   name1   lastName   lastName1    print categories count     prints 3     remove duplicates  and keep initial order of elements  let uniq1    CustomStruct    categories reduce        0 contains  1     0    0     1    print uniq1 count     prints 2 - third element has removed   And just if you are wondering how this reduce magic works - here is exactly the same  but using more expanded reduce syntax  let uniq2    CustomStruct    categories reduce        result  category  in   var newResult   result   if  newResult contains category        else       newResult append category        return newResult   uniq2 count    prints 2 - third element has removed   You can simply copy-paste this code into a Swift Playground and play around

User · Answer

I believe it would be good to offer a uniq   and uniqInPlace   function to mutate an Array by removing it s values  This works similar as the sort   and sortInPlace   function provided by Swift  Also since it s an Array it should keep it s original order of elements   extension Array where Element  Equatable        public func uniq   - gt   Element            var arrayCopy   self         arrayCopy uniqInPlace           return arrayCopy            mutating public func uniqInPlace             var seen    Element            var index   0         for element in self               if seen contains element                    removeAtIndex index                else                   seen append element                  index                                     You can only use uniqInPlace   on a variable Array  i e  var  since you cannot mutate a constant Array  i e  let    Some usage examples   var numbers    1  6  2  2  4  1  5  numbers uniqInPlace      array is now  1  6  2  4  5   let strings     Y    Z    A    Y    B    Y    Z   let uniqStrings   strings uniq      uniqStrings is now   Y    Z    A    B

User · Answer

If you put both extensions in your code  the faster Hashable version will be used when possible  and the Equatable version will be used as a fallback  public extension Sequence where Element  Hashable         The elements of the sequence  with duplicates removed        - Note  Has equivalent elements to  Set self       available    swift  deprecated  5 4    message   quot Doesn t compile without the constant in Swift 5 3  quot        var firstUniqueElements   Element        let getSelf   Element  - gt  Element     self     return firstUniqueElements getSelf         public extension Sequence where Element  Equatable         The elements of the sequence  with duplicates removed        - Note  Has equivalent elements to  Set self       available    swift  deprecated  5 4    message   quot Doesn t compile without the constant in Swift 5 3  quot        var firstUniqueElements   Element        let getSelf   Element  - gt  Element     self     return firstUniqueElements getSelf         public extension Sequence         The elements of the sequences  with  quot duplicates quot  removed       based on a closure    func firstUniqueElements lt Hashable  Swift Hashable gt         getHashable   Element  - gt  Hashable     - gt   Element        var set  Set lt Hashable gt           return filter   set insert getHashable  0   inserted              The elements of the sequence  with  quot duplicates quot  removed        based on a closure    func firstUniqueElements lt Equatable  Swift Equatable gt         getEquatable   Element  - gt  Equatable     - gt   Element        reduce into        uniqueElements  element in       if zip          uniqueElements lazy map getEquatable           AnyIterator    equatable   getEquatable element   in equatable           allSatisfy               uniqueElements append element                       If order isn t important  then you can always just use this Set initializer

User · Answer

Swift 5  extension Sequence where Element  Hashable       func unique   - gt   Element            NSOrderedSet array  self as   Any   array as   Element

User · Answer

You can use directly a set collection to remove duplicate  then cast it back to an array  var myArray    1  4  2  2  6  24  15  2  60  15  6  var mySet   Set lt Int gt  myArray   myArray   Array mySet      2  4  60  6  15  24  1    Then you can order your array as you want  myArray sort  0  lt   1      1  2  4  6  15  24  60

User · Answer

I think this the better way with knowing the logic itself var arrayOfInts    2  2  4  4  var mainArray    Int     for value in arrayOfInts    if mainArray contains value     true             mainArray append value      print  quot mainArray   mainArray  quot

User · Answer

here I ve done some O n  solution for objects  Not few-lines solution  but     struct DistinctWrapper  lt T gt   Hashable       var underlyingObject  T     var distinctAttribute  String     var hashValue  Int           return distinctAttribute hashValue         func distinct lt S   SequenceType  T where S Generator Element    T gt  source  S                                                                  distinctAttribute   T  - gt  String                                                                  resolution   T  T  - gt  T  - gt   T        let wrappers   DistinctWrapper lt T gt     source map           return DistinctWrapper underlyingObject   0  distinctAttribute  distinctAttribute  0              var added   Set lt DistinctWrapper lt T gt  gt        for wrapper in wrappers           if let indexOfExisting   added indexOf wrapper                let old   added indexOfExisting              let winner   resolution old underlyingObject  wrapper underlyingObject              added insert DistinctWrapper underlyingObject  winner  distinctAttribute  distinctAttribute winner              else               added insert wrapper                      return Array added  map    return  0 underlyingObject       func     lt T gt  lhs  DistinctWrapper lt T gt   rhs  DistinctWrapper lt T gt   - gt  Bool       return lhs hashValue    rhs hashValue       tests    case   perhaps we want to get distinct addressbook list which may contain duplicated contacts like Irma and Irma Burgess with same phone numbers    solution   definitely we want to exclude Irma and keep Irma Burgess class Person       var name  String     var phoneNumber  String     init   name  String    phoneNumber  String            self name   name         self phoneNumber   phoneNumber          let persons   Person     Person  Irma Burgess    11-22-33    Person  Lester Davidson    44-66-22    Person  Irma    11-22-33    let distinctPersons   distinct persons      distinctAttribute     person  Person  - gt  String in         return person phoneNumber            resolution         p1  p2  - gt  Person in         return p1 name characters count  gt  p2 name characters count   p1   p2            distinctPersons contains   Irma Burgess    11-22-33   and   Lester Davidson    44-66-22

User · Answer

In Swift 3 0 the simplest and fastest solution I ve found to eliminate the duplicated elements while keeping the order   extension Array where Element Hashable       var unique   Element            var set   Set lt Element gt      the unique list kept in a Set for fast retrieval         var arrayOrdered    Element      keeping the unique list of elements but ordered         for value in self               if  set contains value                    set insert value                  arrayOrdered append value                                   return arrayOrdered

User · Answer

Preserve unique values and preserve sorting in an array     using Swift 3       var top3score   Int             outerLoop  for i in 0   lt top10score count           dlog message  String top10score i             if top3score count    3               break                    for aTop3score in top3score               if aTop3score    top10score i                    continue outerLoop                                  top3score append top10score i               print  top10score is   top10score        14  5  5  5  3  3  2  2  2  2      print  top3score is   top3score         14  5  3

User · Answer

This is just a very simple and convenient implementation  A computed property in an extension of an Array that has equatable elements       extension Array where Element  Equatable           Array containing only  unique  elements      var unique   Element            var result   Element               for element in self               if  result contains element                    result append element                                   return result

User · Answer

Slightly more succinct syntax version of Daniel Krom s Swift 2 answer  using a trailing closure and shorthand argument name  which appears to be based on Airspeed Velocity s original answer   func uniq lt S  SequenceType  E  Hashable where E    S Generator Element gt  source  S  - gt   E      var seen    E  Bool      return source filter   seen updateValue true  forKey   0     nil       Example of implementing a custom type that can be used with uniq      which must conform to Hashable  and thus Equatable  because Hashable extends Equatable    func    lhs  SomeCustomType  rhs  SomeCustomType  - gt  Bool     return lhs id    rhs id     amp  amp  lhs someOtherEquatableProperty    rhs someOtherEquatableProperty    struct SomeCustomType      let id  Int               extension SomeCustomType  Hashable      var hashValue  Int       return id          In the above code     id  as used in the overload of     could be any Equatable type  or method that returns an Equatable type  e g   someMethodThatReturnsAnEquatableType     The commented-out code demonstrates extending the check for equality  where someOtherEquatableProperty is another property of an Equatable type  but could also be a method that returns an Equatable type    id  as used in the hashValue computed property  required to conform to Hashable   could be any Hashable  and thus Equatable  property  or method that returns a Hashable type    Example of using uniq       var someCustomTypes    SomeCustomType id  1   SomeCustomType id  2   SomeCustomType id  3   SomeCustomType id  1    print someCustomTypes count     4  someCustomTypes   uniq someCustomTypes   print someCustomTypes count     3

User · Answer

You can roll your own  e g  like this  func uniq lt S   Sequence  T   Hashable gt  source  S  - gt   T  where S Iterator Element    T       var buffer    T        var added   Set lt T gt        for elem in source           if  added contains elem                buffer append elem              added insert elem                      return buffer    let vals    1  4  2  2  6  24  15  2  60  15  6  let uniqueVals   uniq vals      1  4  2  6  24  15  60   And as an extension for Array  extension Array where Element  Hashable       var uniques  Array           var buffer   Array           var added   Set lt Element gt            for elem in self               if  added contains elem                    buffer append elem                  added insert elem                                  return buffer

User · Answer

Swift 4 x   extension Sequence where Iterator Element  Hashable     func unique   - gt   Iterator Element        return Array Set lt Iterator Element gt  self          func uniqueOrdered   - gt   Iterator Element        return reduce  Iterator Element        0 contains  1     0    0     1            usage     Ljubljana    London    Los Angeles    Ljubljana   unique     or    Ljubljana    London    Los Angeles    Ljubljana   uniqueOrdered

User · Answer

func removeDublicate  ab   Int   - gt   Int    var answer1  Int       for i in ab       if  answer1 contains i            answer1 append i         return answer1     Usage   let f   removeDublicate ab   1 2 2   print f

User · Answer

Here s a more flexible way to make a sequence unique with a custom matching function   extension Sequence where Iterator Element  Hashable        func unique matching   Iterator Element  Iterator Element  - gt  Bool  - gt   Iterator Element             var uniqueArray   Iterator Element               forEach   element in             let isUnique   uniqueArray reduce true     result  item  - gt  Bool in                 return result  amp  amp  matching element  item                             if isUnique                   uniqueArray append element                                  return uniqueArray

User · Answer

Here is a solution that   Uses no legacy NS types Is reasonably fast with O n  Is concise Preserves element order   extension Array where Element  Hashable        var uniqueValues   Element            var allowed   Set self          return compactMap   allowed remove  0

[arrays] Removing duplicate elements from an array in Swift

Examples related to arrays

Examples related to swift

Examples related to standard-library