Sort array by order of values in other array [duplicate]

Answer 1

Swift 3

extension Array where Element: Hashable {
    func getSorted(by: Array<String>) -> Array<String> {
        var d = Dictionary<Int, String>()

        for value in self {
            for i in 0 ..< by.count {
                if value as! String == by[i] {
                    d[i] = value as? String
                }
            }
        }

        var sortedValues = Array<String>()
        for key in d.keys.sorted(by: <) {
            sortedValues.append(d[key]!)
        }

        return sortedValues
    }
}

Answer 2

Update

I've found a better design for this. It has quite a few improvements:

• I use a Dictionary to speed up ordering look-ups
• By extracting this behaviour into a separate type, the dictionary can be cached and reused between multiple sorts
• The ordering-derivation is decoupled from sorting, so it could be used in more ways
• The omitEntirely responsibility was removed entirely. It should instead by done by a simple call to filter, with hardcodedOrdering.contains as the predicate.

See my new answer, here

Answer 3

• Map each array element to a (element, index) tuple, where the index is the index of the array element in the order array. In your example that would be

  [("Lieutenant", 2), ("Captain", 1)]
  

• Sort the array of tuples by the second tuple element (the index). In your case

  [("Captain", 1), ("Lieutenant", 2)]
  

• Extract the array elements from the sorted tuples array. In your case

  ["Captain", "Lieutenant"]
  

Code (for any array of equatable elements, not restricted to arrays of strings):

extension Array where Element: Equatable {
    func getSorted(by orderArray: [Element]) -> [Element] {

        return self.map { ($0, orderArray.index(of: $0) ?? Int.max) }
            .sorted(by: { $0.1 < $1.1 })
            .map { $0.0 }

    }
}

let orderSettingArray = ["Admiral", "Captain", "Lieutenant"]
let myArray = ["Lieutenant", "Captain"]
let myArraySorted = myArray.getSorted(by: orderSettingArray)
print(myArraySorted) // ["Captain", "Lieutenant"]

Elements in myArray which are not present in orderSettingArray are assigned the index Int.max and therefore sorted to the end of the result.

Answer 4

So Easy let new = orderSettingArray.filter{ return myArray.contains($0) }