Как обмениваться элементами в быстром массиве?

Ответ 1

Используйте swap:

var cellOrder = [1,2,3,4]
swap(&cellOrder[0], &cellOrder[1])

В качестве альтернативы вы можете просто назначить его как кортеж:

(cellOrder[0], cellOrder[1]) = (cellOrder[1], cellOrder[0])

Ответ 2

Swift 4

swapAt(_:_:):

cellOrder.swapAt(index0, index1)

Ответ 3

Один из вариантов:

cellOrder[0...1] = [cellOrder[1], cellOrder[0]]

Ответ 4

Используйте метод swapAt,

var arr = [10,20,30,40,50]
arr.swapAt(2, 3)

Используйте индекс для замены элемента.

Ответ 5

Подробнее

• Версия Xcode 10.3 (10G8), Swift 5

Базовый (небезопасный, но быстрый) вариант

unsafe - означает, что вы можете перехватить фатальную ошибку, когда попытаетесь произвести обмен, используя неверный (вне диапазона) индекс элемента в массиве

var array = [1,2,3,4]
// way 1
(array[0],array[1]) = (array[1],array[0])
// way 2
array.swapAt(2, 3)

print(array)

Решение безопасного обмена

• попытка сохранения свопа (проверка индексов)
• можно узнать какой индекс неправильный

не используйте это решение, когда вам нужно поменять много элементов в цикле. Это решение проверяет оба (i, j) индекса (добавьте некоторую дополнительную логику) в функции подкачки, что сделает ваш код медленнее, чем использование стандарта arr.swapAt(i,j). Это идеально подходит для одиночных свопов или для небольшого массива. Но если вы решите использовать стандартный arr.swapAt(i,j), вам придется проверять индексы вручную или быть уверенным, что индексы не выходят за пределы диапазона.

import Foundation

enum SwapError: Error {
    case wrongFirstIndex
    case wrongSecondIndex
}

extension Array {
    mutating func detailedSafeSwapAt(_ i: Int, _ j: Int) throws {
        if !(0..<count ~= i) { throw SwapError.wrongFirstIndex }
        if !(0..<count ~= j) { throw SwapError.wrongSecondIndex }
        swapAt(i, j)
    }

    @discardableResult mutating func safeSwapAt(_ i: Int, _ j: Int) -> Bool {
        do {
            try detailedSafeSwapAt(i, j)
            return true
        } catch {
            return false
        }
    }
}

Использование безопасного обмена

result = arr.safeSwapAt(5, 2)

//or
if arr.safeSwapAt(5, 2) {
    //Success
} else {
    //Fail
}

//or
arr.safeSwapAt(4, 8)

//or
do {
    try arr.detailedSafeSwapAt(4, 8)
} catch let error as SwapError {
    switch error {
    case .wrongFirstIndex: print("Error 1")
    case .wrongSecondIndex: print("Error 2")
    }
}

Полный образец безопасного обмена

var arr = [10,20,30,40,50]
print("Original array: \(arr)")

print("\nSample 1 (with returning Bool = true): ")
var result = arr.safeSwapAt(1, 2)
print("Result: " + (result ? "Success" : "Fail"))
print("Array: \(arr)")

print("\nSample 2 (with returning Bool = false):")
result = arr.safeSwapAt(5, 2)
print("Result: " + (result ? "Success" : "Fail"))
print("Array: \(arr)")

print("\nSample 3 (without returning value):")
arr.safeSwapAt(4, 8)
print("Array: \(arr)")

print("\nSample 4 (with catching error):")
do {
    try arr.detailedSafeSwapAt(4, 8)
} catch let error as SwapError {
    switch error {
    case .wrongFirstIndex: print("Error 1")
    case .wrongSecondIndex: print("Error 2")
    }
}
print("Array: \(arr)")


print("\nSample 5 (with catching error):")
do {
    try arr.detailedSafeSwapAt(7, 1)
} catch let error as SwapError {
    print(error)
}
print("Array: \(arr)")

Полный образец журнала безопасного обмена

Original array: [10, 20, 30, 40, 50]

Sample 1 (with returning Bool = true): 
Result: Success
Array: [10, 30, 20, 40, 50]

Sample 2 (with returning Bool = false):
Result: Fail
Array: [10, 30, 20, 40, 50]

Sample 3 (without returning value):
Array: [10, 30, 20, 40, 50]

Sample 4 (with catching error):
Error 2
Array: [10, 30, 20, 40, 50]

Sample 5 (with catching error):
wrongFirstIndex
Array: [10, 30, 20, 40, 50]