В этом ответе подробно описывается, как перемещаться с быстрым и однородным алгоритмом (Fisher-Yates) в Swift 4.2+ и как добавить ту же функцию в различные предыдущие версии Swift. Именование и поведение для каждой версии Swift соответствуют методам мутирования и немутации для этой версии.

Swift 4.2+

shuffle и shuffled являются родными, начинающими Swift 4.2. Пример использования:

 let x = [1, 2, 3].shuffled() // x == [2, 3, 1] let fiveStrings = stride(from: 0, through: 100, by: 5).map(String.init).shuffled() // fiveStrings == ["20", "45", "70", "30", ...] var numbers = [1, 2, 3, 4] numbers.shuffle() // numbers == [3, 2, 1, 4] 

Swift 4.0 и 4.1

Эти расширения добавляют метод shuffle() к любой изменчивой коллекции (массивы и небезопасные изменяемые буферы) и метод shuffled() для любой последовательности:

 extension MutableCollection { /// Shuffles the contents of this collection. mutating func shuffle() { let c = count guard c > 1 else { return } for (firstUnshuffled, unshuffledCount) in zip(indices, stride(from: c, to: 1, by: -1)) { // Change `Int` in the next line to `IndexDistance` in < Swift 4.1 let d: Int = numericCast(arc4random_uniform(numericCast(unshuffledCount))) let i = index(firstUnshuffled, offsetBy: d) swapAt(firstUnshuffled, i) } } } extension Sequence { /// Returns an array with the contents of this sequence, shuffled. func shuffled() -> [Element] { var result = Array(self) result.shuffle() return result } } 

Такое же использование, как в приведенных выше примерах Swift 4.2.

Swift 3

Эти расширения добавляют метод shuffle() к любой изменчивой коллекции и метод shuffled() для любой последовательности:

 extension MutableCollection where Indices.Iterator.Element == Index { /// Shuffles the contents of this collection. mutating func shuffle() { let c = count guard c > 1 else { return } for (firstUnshuffled , unshuffledCount) in zip(indices, stride(from: c, to: 1, by: -1)) { // Change `Int` in the next line to `IndexDistance` in < Swift 3.2 let d: Int = numericCast(arc4random_uniform(numericCast(unshuffledCount))) guard d != 0 else { continue } let i = index(firstUnshuffled, offsetBy: d) self.swapAt(firstUnshuffled, i) } } } extension Sequence { /// Returns an array with the contents of this sequence, shuffled. func shuffled() -> [Iterator.Element] { var result = Array(self) result.shuffle() return result } } 

Такое же использование, как в приведенных выше примерах Swift 4.2.

Swift 2

(устаревший язык: вы не можете использовать Swift 2.x для публикации в iTunes Connect начиная с июля 2018 года)

 extension MutableCollectionType where Index == Int { /// Shuffle the elements of `self` in-place. mutating func shuffleInPlace() { // empty and single-element collections don't shuffle if count < 2 { return } for i in startIndex ..< endIndex - 1 { let j = Int(arc4random_uniform(UInt32(count - i))) + i guard i != j else { continue } swap(&self[i], &self[j]) } } } extension CollectionType { /// Return a copy of `self` with its elements shuffled. func shuffle() -> [Generator.Element] { var list = Array(self) list.shuffleInPlace() return list } } 

Применение:

 [1, 2, 3].shuffle() // [2, 3, 1] let fiveStrings = 0.stride(through: 100, by: 5).map(String.init).shuffle() // ["20", "45", "70", "30", ...] var numbers = [1, 2, 3, 4] numbers.shuffleInPlace() // [3, 2, 1, 4] 

Swift 1.2

(устаревший язык: вы не можете использовать Swift 1.x для публикации в iTunes Connect начиная с июля 2018 года)

shuffle как метод мутирующих массивов

Это расширение позволит вам перетасовать изменяемый экземпляр Array на месте:

 extension Array { mutating func shuffle() { if count < 2 { return } for i in 0..<(count - 1) { let j = Int(arc4random_uniform(UInt32(count - i))) + i swap(&self[i], &self[j]) } } } var numbers = [1, 2, 3, 4, 5, 6, 7, 8] numbers.shuffle() // eg, numbers == [6, 1, 8, 3, 2, 4, 7, 5] 

shuffled как метод без мутирующих массивов

Это расширение позволит вам получить перетасованную копию экземпляра Array :

 extension Array { func shuffled() -> [T] { if count < 2 { return self } var list = self for i in 0..<(list.count - 1) { let j = Int(arc4random_uniform(UInt32(list.count - i))) + i swap(&list[i], &list[j]) } return list } } let numbers = [1, 2, 3, 4, 5, 6, 7, 8] let mixedup = numbers.shuffled() // eg, mixedup == [6, 1, 8, 3, 2, 4, 7, 5] 

Изменить: Как отмечено в других ответах, Swift 4.2, наконец, добавляет случайное число в стандартную библиотеку в комплекте с перетасовкой массива.

Однако GKRandom / GKRandomDistribution в GameplayKit все еще может быть полезен с новым протоколом RandomNumberGenerator – если вы добавите расширения в RandomNumberGenerator GameplayKit, чтобы соответствовать новому стандартному протоколу библиотеки, вы можете легко получить:

• (которые могут воспроизводить «случайную» последовательность, когда это необходимо для тестирования)
• ГСЧ, которые приносят в жертву устойчивость к скорости
• ГСЧ, которые производят неравномерные распределения

… и по-прежнему используют хорошие новые «родные» случайные API в Swift.

Остальная часть этого ответа касается таких RNG и / или их использования в старых компиляторах Swift.

Здесь есть несколько хороших ответов, а также некоторые хорошие иллюстрации того, почему создание собственного тасования может быть подвержено ошибкам, если вы не будете осторожны.

В iOS 9, macOS 10.11 и tvOS 9 (или позже) вам не нужно писать свои собственные. Эффективная и правильная реализация Fisher-Yates в GameplayKit (которая, несмотря на название, не только для игр).

Если вы просто хотите уникальную перетасовку:

 let shuffled = GKRandomSource.sharedRandom().arrayByShufflingObjects(in: array) 

Если вы хотите, чтобы у вас была возможность повторить тасовку или череду перетасовки, выберите и запустите определенный случайный источник; например

 let lcg = GKLinearCongruentialRandomSource(seed: mySeedValue) let shuffled = lcg.arrayByShufflingObjects(in: array) 

В iOS 10 / macOS 10.12 / tvOS 10 есть также удобный синтаксис для перетасовки через расширение на NSArray . Конечно, это немного громоздко, когда вы используете Swift Array (и он теряет свой тип элемента при возврате в Swift):

 let shuffled1 = (array as NSArray).shuffled(using: random) // -> [Any] let shuffled2 = (array as NSArray).shuffled() // use default random source 

Но для нее довольно легко создать поддерживающую тип Swift-оболочку:

 extension Array { func shuffled(using source: GKRandomSource) -> [Element] { return (self as NSArray).shuffled(using: source) as! [Element] } func shuffled() -> [Element] { return (self as NSArray).shuffled() as! [Element] } } let shuffled3 = array.shuffled(using: random) let shuffled4 = array.shuffled() 

В Swift 2.0 GameplayKit может прийти на помощь! (поддерживается iOS9 или более поздней версией )

 import GameplayKit func shuffle() { array = GKRandomSource.sharedRandom().arrayByShufflingObjectsInArray(array) } 

Вот что-то возможно немного короче:

 sorted(a) {_, _ in arc4random() % 2 == 0} 

Принимая алгоритм Нейта, я хотел посмотреть, как это будет выглядеть с помощью Swift 2 и расширений протокола.

Это то, что я придумал.

 extension MutableCollectionType where Self.Index == Int { mutating func shuffleInPlace() { let c = self.count for i in 0..<(c - 1) { let j = Int(arc4random_uniform(UInt32(c - i))) + i swap(&self[i], &self[j]) } } } extension MutableCollectionType where Self.Index == Int { func shuffle() -> Self { var r = self let c = self.count for i in 0..<(c - 1) { let j = Int(arc4random_uniform(UInt32(c - i))) + i swap(&r[i], &r[j]) } return r } } 

Теперь любой MutableCollectionType может использовать эти методы, учитывая, что он использует Int как Index

В моем случае у меня были проблемы с обменом объектами в массиве. Затем я поцарапал себе голову и стал изобретать колесо.

 // swift 3.0 ready extension Array { func shuffled() -> [Element] { var results = [Element]() var indexes = (0 ..< count).map { $0 } while indexes.count > 0 { let indexOfIndexes = Int(arc4random_uniform(UInt32(indexes.count))) let index = indexes[indexOfIndexes] results.append(self[index]) indexes.remove(at: indexOfIndexes) } return results } } 

Это версия реализации Nate Shisher для Fisher-Yates для Swift 4 (Xcode 9).

 extension MutableCollection { /// Shuffle the elements of `self` in-place. mutating func shuffle() { for i in indices.dropLast() { let diff = distance(from: i, to: endIndex) let j = index(i, offsetBy: numericCast(arc4random_uniform(numericCast(diff)))) swapAt(i, j) } } } extension Collection { /// Return a copy of `self` with its elements shuffled func shuffled() -> [Element] { var list = Array(self) list.shuffle() return list } } 

Изменения следующие:

• Индекс ограничений Indices.Iterator.Element == Index теперь является частью протокола Collection , и его больше не нужно накладывать на расширение.
• Обмен элементами должен выполняться путем вызова swapAt() в коллекции, сравните SE-0173 Add MutableCollection.swapAt(_:_:) .
• Element является псевдонимом для Iterator.Element .

Это то, что я использую:

 func newShuffledArray(array:NSArray) -> NSArray { var mutableArray = array.mutableCopy() as! NSMutableArray var count = mutableArray.count if count>1 { for var i=count-1;i>0;--i{ mutableArray.exchangeObjectAtIndex(i, withObjectAtIndex: Int(arc4random_uniform(UInt32(i+1)))) } } return mutableArray as NSArray } 

Swift 4 Перемешать элементы массива в цикле for, где i – коэффициент смешивания

 var cards = [Int]() //Some Array let i = 4 // is the mixing ratio func shuffleCards() { for _ in 0 ..< cards.count * i { let card = cards.remove(at: Int(arc4random_uniform(UInt32(cards.count)))) cards.insert(card, at: Int(arc4random_uniform(UInt32(cards.count)))) } } 

Или с расширением Int

 func shuffleCards() { for _ in 0 ..< cards.count * i { let card = cards.remove(at: cards.count.arc4random) cards.insert(card, at: cards.count.arc4random) } } extension Int { var arc4random: Int { if self > 0 { print("Arc for random positiv self \(Int(arc4random_uniform(UInt32(self))))") return Int(arc4random_uniform(UInt32(self))) } else if self < 0 { print("Arc for random negotiv self \(-Int(arc4random_uniform(UInt32(abs(self)))))") return -Int(arc4random_uniform(UInt32(abs(self)))) } else { print("Arc for random equal 0") return 0 } } } 

Swift 3, после ответа @Nate Cook: (работайте, если индекс начинается с 0, см. Комментарии ниже)

 extension Collection { /// Return a copy of `self` with its elements shuffled func shuffle() -> [Generator.Element] { var list = Array(self) list.shuffleInPlace() return list } } extension MutableCollection where Index == Int { /// Shuffle the elements of `self` in-place. mutating func shuffleInPlace() { // empty and single-element collections don't shuffle if count < 2 { return } let countInt = count as! Int for i in 0.. 

Вот как это делается простейшим способом. import Gamplaykit в свой VC и используйте приведенный ниже код. Протестировано в Xcode 8.

  import GameplayKit let array: NSArray = ["Jock", "Ellie", "Sue Ellen", "Bobby", "JR", "Pamela"] override func viewDidLoad() { super.viewDidLoad() print(array.shuffled()) } 

Если вы хотите получить перетасованную строку из массива, вы можете использовать код ниже.

 func suffleString() { let ShuffleArray = array.shuffled() suffleString.text = ShuffleArray.first as? String print(suffleString.text!) } 

С Swift 3, если вы хотите перетасовать массив на месте или получить новый перетасованный массив из массива, AnyIterator может вам помочь. Идея состоит в том, чтобы создать массив индексов из вашего массива, чтобы перетасовать эти индексы с экземпляром AnyIterator и AnyIterator swap(_:_:) и сопоставить каждый элемент этого экземпляра AnyIterator с соответствующим элементом массива.

Следующий код площадки показывает, как он работает:

 import Darwin // required for arc4random_uniform let array = ["Jock", "Ellie", "Sue Ellen", "Bobby", "JR", "Pamela"] var indexArray = Array(array.indices) var index = indexArray.endIndex let indexIterator: AnyIterator = AnyIterator { guard let nextIndex = indexArray.index(index, offsetBy: -1, limitedBy: indexArray.startIndex) else { return nil } index = nextIndex let randomIndex = Int(arc4random_uniform(UInt32(index))) if randomIndex != index { swap(&indexArray[randomIndex], &indexArray[index]) } return indexArray[index] } let newArray = indexIterator.map { array[$0] } print(newArray) // may print: ["Jock", "Ellie", "Sue Ellen", "JR", "Pamela", "Bobby"] 

Вы можете реорганизовать предыдущий код и создать функцию shuffled() внутри расширения Array , чтобы получить новый массив с перетасовкой из массива:

 import Darwin // required for arc4random_uniform extension Array { func shuffled() -> Array { var indexArray = Array(indices) var index = indexArray.endIndex let indexIterator = AnyIterator { guard let nextIndex = indexArray.index(index, offsetBy: -1, limitedBy: indexArray.startIndex) else { return nil } index = nextIndex let randomIndex = Int(arc4random_uniform(UInt32(index))) if randomIndex != index { swap(&indexArray[randomIndex], &indexArray[index]) } return indexArray[index] } return indexIterator.map { self[$0] } } } 

Применение:

 let array = ["Jock", "Ellie", "Sue Ellen", "Bobby", "JR", "Pamela"] let newArray = array.shuffled() print(newArray) // may print: ["Bobby", "Pamela", "Jock", "Ellie", "JR", "Sue Ellen"] 

 let emptyArray = [String]() let newEmptyArray = emptyArray.shuffled() print(newEmptyArray) // prints: [] 

В качестве альтернативы предыдущему коду вы можете создать функцию shuffle() внутри расширения Array , чтобы перетасовать массив на месте:

 import Darwin // required for arc4random_uniform extension Array { mutating func shuffle() { var indexArray = Array(indices) var index = indexArray.endIndex let indexIterator = AnyIterator { guard let nextIndex = indexArray.index(index, offsetBy: -1, limitedBy: indexArray.startIndex) else { return nil } index = nextIndex let randomIndex = Int(arc4random_uniform(UInt32(index))) if randomIndex != index { swap(&indexArray[randomIndex], &indexArray[index]) } return indexArray[index] } self = indexIterator.map { self[$0] } } } 

Применение:

 var mutatingArray = ["Jock", "Ellie", "Sue Ellen", "Bobby", "JR", "Pamela"] mutatingArray.shuffle() print(mutatingArray) // may print ["Sue Ellen", "Pamela", "Jock", "Ellie", "Bobby", "JR"] 

Формируйте статью Фишера-Йейта в Shuffle в Википедии

Свифт 3,1,4,0

а). Карандаш-бумажный метод:

 func shuffle(_ array:inout [T]){ var temp = [T]() for _ in array{ /*Generating random number with length*/ let random = arc4random_uniform(UInt32(array.count)) /*Take the element from array*/ let elementTaken = array[Int(random)] /*Append it to new tempArray*/ temp.append(elementTaken) /*Remove the element from array*/ array.remove(at: Int(random)) } /* array = tempArray*/ array = temp } 

б). Современный метод: (версия Дюрстенфельда)

 func shuffle(_ array:inout [T]){ var length = array.count for _ in array{ /*Generating random number with length*/ let random = arc4random_uniform(UInt32(length)) /*Check before index of two elements not same*/ if length-1 != Int(random){ swap(&array[length-1], &array[Int(random)]) } length -= 1 } } 

Extension:

а). Карандаш-бумажный метод:

 extension Array{ mutating func shuffled(){ var temp = [Element]() for _ in self{ /*Generating random number with length*/ let random = arc4random_uniform(UInt32(self.count)) /*Take the element from array*/ let elementTaken = self[Int(random)] /*Append it to new tempArray*/ temp.append(elementTaken) /*Remove the element from array*/ self.remove(at: Int(random)) } /* array = tempArray*/ self = temp } } 

б). Современный метод: (версия Дюрстенфельда)

 extension Array{ mutating func shuffled(){ var length = self.count for _ in self{ /*Generating random number with length*/ let random = arc4random_uniform(UInt32(length)) /*Check before index of two elements not same*/ if length-1 != Int(random){ /*Swaping elements, If same index then there is no swap*/ // swap(&self[length-1], &self[Int(random)]) -> Swift 3.0 self.swapAt(length-1, Int(random)) //-> Swift 4.0 } length -= 1 } } } 

Справка :

 /* By using shuffle functions*/ var a = [1,2,3,4,5,6,7,8,9,10] for _ in 1...10{ self.shuffle(&a) /*For shuffled extension, a.shuffled()*/ print(a) } 

Примечание. Вы также можете использовать пустой массив.

Вывод:

[6, 2, 10, 5, 1, 8, 9, 4, 3, 7]

[7, 1, 9, 8, 2, 10, 5, 6, 4, 3]

[8, 9, 6, 10, 5, 2, 7, 4, 3, 1]

[10, 1, 7, 4, 8, 9, 3, 5, 2, 6]

[8, 1, 6, 9, 3, 7, 4, 5, 10, 2]

[4, 3, 7, 9, 1, 5, 8, 6, 10, 2]

[7, 3, 4, 9, 10, 1, 6, 5, 2, 8]

[3, 6, 2, 4, 5, 8, 9, 7, 1, 10]

[5, 1, 2, 10, 6, 9, 7, 3, 8, 4]

[7, 9, 3, 8, 2, 1, 5, 4, 6, 10]

Пожалуйста, дайте мне знать, если какие-либо запросы, другая версия Swift будет проверяться в ближайшее время.

Вы также можете использовать общую функцию swap и реализовать упомянутые Fisher-Yates:

 for idx in 0.. 

 for idx in 0..