Comment réorganiser les éléments d'un tableau vers une nouvelle position en Swift ?

Question

Considérons le tableau [1,2,3,4] . Comment puis-je réorganiser les éléments du tableau vers une nouvelle position.

Par exemple :

put 3 into position 4 [1,2,4,3]

put 4 in to position 1 [4,1,2,3]

put 2 into position 3 [1,3,2,4] .

Answer 1

Swift 3.0+ :

let element = arr.remove(at: 3)
arr.insert(element, at: 2)

et sous forme de fonction :

func rearrange<T>(array: Array<T>, fromIndex: Int, toIndex: Int) -> Array<T>{
    var arr = array
    let element = arr.remove(at: fromIndex)
    arr.insert(element, at: toIndex)

    return arr
}

Swift 2.0 :

Le chiffre 3 se retrouve ainsi en position 4.

let element = arr.removeAtIndex(3)
arr.insert(element, atIndex: 2)

Vous pouvez même créer une fonction générale :

func rearrange<T>(array: Array<T>, fromIndex: Int, toIndex: Int) -> Array<T>{
    var arr = array
    let element = arr.removeAtIndex(fromIndex)
    arr.insert(element, atIndex: toIndex)

    return arr
}

Les var arr est nécessaire ici, car vous ne pouvez pas modifier le paramètre d'entrée sans spécifier qu'il s'agit de in-out . Dans notre cas, cependant, nous obtenons des fonctions pures sans effets secondaires, ce qui est beaucoup plus facile à raisonner, à mon avis. Vous pourriez alors l'appeler comme ceci :

let arr = [1,2,3,4]
rearrange(arr, fromIndex: 2, toIndex: 0) //[3,1,2,4]

Answer 2

Toutes les réponses sont excellentes ! Voici une réponse plus complète Swift 5 Cette solution a été conçue dans un souci de performance et constitue un bonus pour les amateurs d'analyses comparatives et de GIF.

extension Array where Element: Equatable
{
    mutating func move(_ element: Element, to newIndex: Index) {
        if let oldIndex: Int = self.firstIndex(of: element) { self.move(from: oldIndex, to: newIndex) }
    }
}

extension Array
{
    mutating func move(from oldIndex: Index, to newIndex: Index) {
        // Don't work for free and use swap when indices are next to each other - this
        // won't rebuild array and will be super efficient.
        if oldIndex == newIndex { return }
        if abs(newIndex - oldIndex) == 1 { return self.swapAt(oldIndex, newIndex) }
        self.insert(self.remove(at: oldIndex), at: newIndex)
    }
}

Answer 3

Modifier/mettre à jour : Swift 3.x

extension RangeReplaceableCollection where Indices: Equatable {
    mutating func rearrange(from: Index, to: Index) {
        precondition(from != to && indices.contains(from) && indices.contains(to), "invalid indices")
        insert(remove(at: from), at: to)
    }
}

---

var numbers = [1,2,3,4]
numbers.rearrange(from: 1, to: 2)

print(numbers)  // [1, 3, 2, 4]

Answer 4

Bon conseil de la part de Leo.

pour Swift 3 :

extension Array {  
    mutating func rearrange(from: Int, to: Int) {
        insert(remove(at: from), at: to)
    }
}

var myArray = [1,2,3,4]
myArray.rearrange(from: 1, to: 2)   
print(myArray)

Answer 5

Nous pouvons utiliser la méthode swap pour échanger des éléments dans un tableau :

var arr = ["one", "two", "three", "four", "five"]

// Swap elements at index: 2 and 3
print(arr)
swap(&arr[2], &arr[3])
print(arr)