Как изменить массив в Swift без использования ".reverse()"?

Ответ 1

Вот ответ @Abhinav, переведенный на Swift 2.2:

var names: [String] = ["Apple", "Microsoft", "Sony", "Lenovo", "Asus"]

var reversedNames = [String]()

for arrayIndex in (names.count - 1).stride(through: 0, by: -1) {
    reversedNames.append(names[arrayIndex])
}

Использование этого кода не должно давать вам ошибок или предупреждений об использовании устаревших циклов for в стиле C или использовании --.

Свифт 3 - Текущий:

let names: [String] = ["Apple", "Microsoft", "Sony", "Lenovo", "Asus"]

var reversedNames = [String]()

for arrayIndex in stride(from: names.count - 1, through: 0, by: -1) {
    reversedNames.append(names[arrayIndex])
}

В качестве альтернативы, вы можете выполнить цикл как обычно и вычитать каждый раз:

let names = ["Apple", "Microsoft", "Sony", "Lenovo", "Asus"]

let totalIndices = names.count - 1 // We get this value one time instead of once per iteration.

var reversedNames = [String]()

for arrayIndex in 0...totalIndices {
    reversedNames.append(names[totalIndices - arrayIndex])
}

Ответ 2

Swift 3:

var names:[String] = ["Apple", "Microsoft", "Sony", "Lenovo", "Asus"]

var reversedNames : [String] = Array(names.reversed())

print(reversedNames)  // ["Asus", "Lenovo", "Sony", "Microsoft", "Apple"]

Ответ 3

¿Это необходимо для loop? Если нет, вы можете использовать reduce.

Я предполагаю, что это самый короткий способ его достижения без метода reverse() (Swift 3.0.1):

["Apple", "Microsoft", "Sony", "Lenovo", "Asus"].reduce([],{ [$1] + $0 })

Ответ 4

var names:[String] = [ "A", "B", "C", "D", "E","F","G"]
var c = names.count - 1
var i = 0
while i < c {
    swap(&names[i++],&names[c--])
}

Ответ 5

Там также stride для создания обратного индекса:

let names = ["Apple", "Microsoft", "Sony", "Lenovo", "Asus"]

var reversed = [String]()

for index in (names.count - 1).stride(to: -1, by: -1) {
    reversed.append(names[index])
}

Он также хорошо работает с map:

let reversed = (names.count - 1).stride(to: -1, by: -1).map { names[$0] }

Примечание: stride начинает свой индекс с 1, а не 0, вопреки другим последовательностям Swift.

Тем не менее, любому, кто читает это в будущем: используйте .reverse() вместо этого, чтобы фактически изменить массив, это предполагаемый путь.

Ответ 6

Здесь вы идете:

var names:[String] = ["Apple", "Microsoft", "Sony", "Lenovo", "Asus"]

var reversedNames = [String]()

for var arrayIndex = names.count - 1 ; arrayIndex >= 0 ; arrayIndex-- {
    reversedNames.append(names[arrayIndex])
}

Ответ 7

Только нужно сделать (names.count/2) проходит через массив. Нет необходимости объявлять временную переменную при выполнении свопа... он неявный.

var names:[String] = ["Apple", "Microsoft", "Sony", "Lenovo", "Asus"]
let count = names.count
for i in 0..<count/2 {
   (names[i],names[count - i - 1])  = (names[count - i - 1],names[i])
}
// Yields: ["Asus", "Lenovo", "Sony", "Microsoft", "Apple"]

Ответ 8

Здесь код для быстрого 3

let array = ["IOS A", "IOS B", "IOS C"]
    for item in array.reversed() {
    print("Found \(item)")
    }

Ответ 9

// Swap the first index with the last index.
// [1, 2, 3, 4, 5] -> pointer on one = array[0] and two = array.count - 1
// After first swap+loop increase the pointer one and decrease pointer two until
// conditional is not true. 

func reverseInteger(array: [Int]) -> [Int]{
        var array = array
        var first = 0
        var last = array.count - 1
        while first < last {
            array.swapAt(first, last)
            first += 1
            last -= 1
        }
        return array
    }

input-> [1, 2, 3, 4, 5] return->[5, 4, 3, 2, 1]

Ответ 10

вы имеете в виду

var names = ["Apple", "Microsoft", "Sony", "Lenovo", "Asus"]
var newNames = [String]()

for var i = names.count - 1; i >= 0 ; i-- {
  newNames.append(names[i])
}
names = newNames

или

names.map {newNames.insert($0, atIndex: 0)}
names = newNames

Ответ 11

Нравится это, возможно:

names = names.enumerate().map() { ($0.index, $0.element) }.sort() { $0.0 > $1.0 }.map() { $0.1 }

Ой, подождите.. Я должен использовать цикл for, правильно? Тогда вот так:

for (index, name) in names.enumerate().map({($0.index, $0.element)}).sort({$0.0 > $1.0}).map({$0.1}).enumerate() {
    names[index] = name
}

Ответ 12

Игнорирование проверок на пустоту.

var names:[String] = ["Apple", "Microsoft", "Sony", "Lenovo", "Asus"]

var reversedNames: [String]
reversedNames = []

for name in names {
    reversedNames.insert((name), atIndex:0)
}

Ответ 13

Это будет работать с любым размером массива.

import Cocoa

var names:[String] = [ "A", "B", "C", "D", "E","F"]
var c = names.count - 1
for i in 0...(c/2-1) { swap(&names[i],&names[c-i]) }

print(names)

Ответ 14

Просто для удовольствия:

var names:[String] = ["Apple", "Microsoft", "Sony", "Lenovo", "Asus"]
if !names.isEmpty {
    for index in 0...names.count-1 {
       names.insert(names.removeAtIndex(index), atIndex: 0)
    }
}
print(names)  // ["Asus", "Lenovo", "Sony", "Microsoft", "Apple"]\n"

Ответ 15

Для удовольствия другая опция, использующая append вместо insert (atIndex:):

var names:[String] = ["Apple", "Microsoft", "Sony", "Lenovo", "Asus"]
if !names.isEmpty {
    for index in 0...names.count-1 {
        names.append(names.removeAtIndex(names.count-1 - index))
    }
}
print(names)  // ["Asus", "Lenovo", "Sony", "Microsoft", "Apple"]\n"

Ответ 16

Вот как я это сделал, и нет предупреждения для Swift 3

let names = ["Apple", "Microsoft", "Sony", "Lenovo", "Asus"]
var reversedNames = [String]()

for name in names.enumerate() {
  let newIndex = names.count - 1 - name.index
  reversedNames.append(names[newIndex])
}

или просто просто

reversedNames = names.reverse()

Ответ 17

func reverse(array: inout [String]) {
    if array.isEmpty { return }
    var f = array.startIndex
    var l = array.index(before: array.endIndex)
    while f < l {
        swap(array: &array, f, l)
        array.formIndex(after: &f)
        array.formIndex(before: &l)
    }
}

private func swap( array: inout [String], _ i: Int, _ j: Int) {
    guard i != j else { return }
    let tmp = array[i]
    array[i] = array[j]
    array[j] = tmp
}

Или вы можете написать расширение курса

Ответ 18

var rArray : [Int] = [2,5,6,8,3,8,9,10]
var ReArray = [Int]()
var a : Int = 1

func reversed (_ array: [Int]) -> [Int] {
    for i in array {
        ReArray.append(array[array.count-a])
        a += 1
    }

    rArray = ReArray

    return rArray
}

reversed(rArray)

print(rArray)

Ответ 19

Вы можете использовать документ swift3:

let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
let reversedNames = names.sorted(by: >)

// reversedNames is equal to:
//   ["Ewa", "Daniella", "Chris", "Barry", "Alex"]

Ответ 20

Сделайте это так для обратной сортировки.

 let unsortedArray: [String] = ["X", "B", "M", "P", "Z"]
        // reverse sorting
        let reversedArray = unsortedArray.sorted() {$0 > $1}

        print(reversedArray) // ["Z", "X", "P", "M", "B"]

Ответ 21

Вот самый простой способ.

let names:[String] = ["Apple", "Microsoft", "Sony", "Lenovo", "Asus"]

var reversedNames = [String]()

for name in names {
    reversedNames.insert(name, at: 0)
}

Ответ 22

var arr = [1,2,3,4,5]   // Array we want to reverse
var reverse:[Int]!      // Array where we store reversed values

reverse = arr

for i in 0...arr.count - 1 {

    reverse[i] = arr.last!  // Adding last value of original array at reverse[0]
    arr.removeLast()        // removing last value & repeating above step.
}

print("Reverse : \(reverse!)")

Более простой способ :)

Ответ 23

var array = [3,2,1]
array = array.reversed()