How to do iterated moves of items in an array in Swift - arrays

Question

Let's say we have an array:
var scrambledAlphabet = ["B", "C", "D", "E", "H", "F", "G", "A"]
and we want sort it by moving two items: item 7 ("A") to location 0, and item 4 ("H") to 7, described with an array of tuples:
var moves = [(7, 0), (4, 7)]
So, the desired result is:
["A", "B", "C", "D", "E", "F", "G", "H"]
Spontaneous that would be easy solved with this:
var scrambledAlphabet = ["B", "C", "D", "E", "H", "F", "G", "A"]
var moves = [(7, 0), (4, 7)]
for (i, j) in moves {
scrambledAlphabet.insert(scrambledAlphabet.remove(at: i), at: j)
}
print(scrambledAlphabet)
But it doesn't work. The output is:
["A", "B", "C", "D", "H", "F", "G", "E"]
The problem is that once the first item is moved, the index of the next item is altered. So, what would be the best way to tackle this? I find this surprisingly hard to crack. Any help is appreciated.
The restriction is that the two variables, scrambledAlphabet and moves, must be able to grow to any number.
And also one important note, the move-to-index (second number in the tuple) is referring to the old array, not the newly created. So, the inputs ["B", "C", "E", "D", "H", "F", "G", "A"] and [(7, 0), (4, 7), (3, 2)] should result in:
["A", "B", "C", "D", "E", "F", "G", "H"]
Sorry about the confusion about this last bit.

Answer 1

I thought of this (IMO a little clumsy) solution:
var newArray = Array(repeating: "", count: scrambledLetters.count)
for (start, end) in moves {
newArray[end] = scrambledLetters[start]
scrambledLetters[start] = ""
}
var scrambledLetterIndex = -1
func setScrambledLetterIndexToNextNonEmptyString() {
scrambledLetterIndex += 1
while scrambledLetterIndex < scrambledLetters.count - 1 && scrambledLetters[scrambledLetterIndex].isEmpty {
scrambledLetterIndex += 1
}
}
for i in newArray.indices {
if newArray[i] == "" {
setScrambledLetterIndexToNextNonEmptyString()
newArray[i] = scrambledLetters[scrambledLetterIndex]
}
}
scrambledLetters = newArray
Essentially, I first created a new array, and "took out" the strings that needs to be moved, and placed them in the correct position in the new array. That's what the first for loop did.
After the first for loop, the two arrays will look like this:
scrambledLetters: ["B", "C", "D", "E", "", "F", "G", ""]
newArray: ["A", "", "", "", "", "", "" , "H"]
Then, I slowly copied each non-empty item in the scrambled letters array into the new array's empty places.
Because this solution makes use of the empty string, it won't work if the input domain contained empty strings. If that's the case, you'd have to use something like a [String?].

Answer 2

A possible approach is to use an array of all indices which are not the source of any move. Then we can fill the destination sequentially, either from one of the moves, or from one of the “other indices”:
func scramble<T>(array: [T], moves: [(Int, Int)]) -> [T] {
// Moves sorted by increasing destination index:
var moves = moves.sorted(by: { $0.1 < $1.1 })
// All indices which are not the source of a move:
let sourceIndices = Set(moves.map { $0.0 })
var otherIndices = array.indices.filter { !sourceIndices.contains($0)}
// Fill each position with an element of a move source,
// or one of the "other" array elements:
return array.indices.map {
if let (from, to) = moves.first, $0 == to {
moves.removeFirst()
return array[from]
} else {
return array[otherIndices.removeFirst()]
}
}
}
Example 1:
print(scramble(array: ["B", "C", "D", "E", "H", "F", "G", "A"],
moves: [(7, 0), (4, 7)]))
// ["A", "B", "C", "D", "E", "F", "G", "H"]
Example 2:
print(scramble(array: [0, 1, 2, 3, 4, 5, 6, 7],
moves: [(1, 6), (7, 2), (3, 5), (5, 3), (4, 7)]))
// [0, 2, 7, 5, 6, 3, 1, 4]

Answer 3

I solved it by couple the items in the array with their original index, and sorted the moves so that the inserts doesn't scramble the order. Also moved all code into an array extension:
extension Array where Element : Equatable {
mutating func moveItem(from fromIndex: Int, to toIndex: Int) {
self.insert(self.remove(at: fromIndex), at: toIndex)
}
func performIteratedMoves(_ moves: [(Int, Int)]) -> [Element] {
var array = self
let enumeratedArray = array.enumerated().map{ (index: $0, item: $1) }
let sortedMoves = moves.sorted { $0.1 > $1.1 }
for (i, j) in sortedMoves {
guard let (_, item) = enumeratedArray.first(where:{ $0.index == i }), let correctIndex = array.firstIndex(where:{ $0 == item }) else { continue }
array.moveItem(from: correctIndex, to: j)
}
return array
}
}
Usage:
var scrambledAlphabet = ["B", "C", "E", "D", "H", "F", "G", "A"]
var moves = [(7, 0), (4, 7), (3, 2)]
print(scrambledAlphabet.performIteratedMoves(moves))
// ["A", "B", "C", "D", "E", "F", "G", "H"]