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

Question

This question already has answers here:

Sorting a Swift array by ordering from another array (11 answers)

Closed 6 years ago.

I have one array that defines an order,

let orderSettingArray = ["Admiral", "Captain", "Lieutenant"]

and another array with a few of these values

var myArray = ["Lieutenant", "Captain"]

I want to sort myArray to reflect the order of orderSettingArray:

var myArraySorted = myArray.getSorted(by: orderSettingArray)

Now print(myArraySorted) should print ["Captain", "Lieutenant"]

• Alexander: Military ranks are one of the ideal use cases for enums. You should take advantage of that.
• Martin R: @NiravD: You are right (and I should have known about that one :) – This question is a tiny bit more general because it asks for an array extension method, but the underlying ideas are the same. Let's wait for more opinions whether to close this as a duplicate or not.
• Nirav D: @MartinR I know​ that's why I added duplicates question as just suggestion
• JOG: The military ranks are just an example. The real scenario has customizable strings. @Alexander

Answer 1

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

Answer 2

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

• Ahmad F: Hello, Don't you think that this answer is even simpler? and it should be applicable for any array of equatable elements, not restricted to arrays of strings...
• Martin R: @AhmadF: The difference is that it won't handle repeated elements in myArray, or elements in myArray which are not in orderSettingArray. If that is not an issue, the solution is fine.

Answer 3

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

• JOG: Wow, such a great exhaustive answer.
• Alexander: @JOG yeah, it's an operation I've had to do several times, so I've spent quite a some time building and refining this

Answer 4

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

• Ahmad F: Note that this is only functional for [String]
• Alexander: Oh boy, this is unnecessarily complex.
• JOG: Not optimal, sure. Complex, nah. :)