arrays - initialize - swift foreach
¿Cómo puedo mezclar una matriz en Swift? (25)
¿Cómo puedo aleatorizar o mezclar los elementos dentro de una matriz en Swift? Por ejemplo, si mi matriz consta de 52 cartas, quiero barajar la matriz para barajar la baraja.
Extensión de la matriz de trabajo (mutación y no mutación)
Swift 4.1 / Xcode 9
La respuesta principal está en desuso, así que me encargué de crear mi propia extensión para mezclar una matriz en la versión más reciente de Swift, Swift 4.1 (Xcode 9):
extension Array {
// Non-mutating shuffle
var shuffled : Array {
let totalCount : Int = self.count
var shuffledArray : Array = []
var count : Int = totalCount
var tempArray : Array = self
for _ in 0..<totalCount {
let randomIndex : Int = Int(arc4random_uniform(UInt32(count)))
let randomElement : Element = tempArray.remove(at: randomIndex)
shuffledArray.append(randomElement)
count -= 1
}
return shuffledArray
}
// Mutating shuffle
mutating func shuffle() {
let totalCount : Int = self.count
var shuffledArray : Array = []
var count : Int = totalCount
var tempArray : Array = self
for _ in 0..<totalCount {
let randomIndex : Int = Int(arc4random_uniform(UInt32(count)))
let randomElement : Element = tempArray.remove(at: randomIndex)
shuffledArray.append(randomElement)
count -= 1
}
self = shuffledArray
}
}
Llamar a Shuffle no mutante [Array] -> [Array]
:
let array = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
print(array.shuffled)
Esto imprime la array
en un orden aleatorio.
Call Mutating Shuffle [Array] = [Array]
:
var array = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
array.shuffle()
// The array has now been mutated and contains all of its initial
// values, but in a randomized shuffled order
print(array)
Esto imprime la array
en su orden actual, que ya se ha barajado aleatoriamente.
Espera que esto funcione para todos, si tiene preguntas, sugerencias o comentarios, ¡no dude en preguntar!
¡¡trabajos!!. Los organismos son la matriz para barajar.
extension Array
{
/** Randomizes the order of an array''s elements. */
mutating func shuffle()
{
for _ in 0..<10
{
sort { (_,_) in arc4random() < arc4random() }
}
}
}
var organisms = [
"ant", "bacteria", "cougar",
"dog", "elephant", "firefly",
"goat", "hedgehog", "iguana"]
print("Original: /(organisms)")
organisms.shuffle()
print("Shuffled: /(organisms)")
¡En Swift 2.0 , GameplayKit puede venir al rescate! (soportado por iOS9 o posterior)
import GameplayKit
func shuffle() {
array = GKRandomSource.sharedRandom().arrayByShufflingObjectsInArray(array)
}
Aquí hay algo posiblemente un poco más corto:
sorted(a) {_, _ in arc4random() % 2 == 0}
Aquí hay un código que se ejecuta en el patio de recreo. No necesitarás importar Darwin en un proyecto Xcode real.
import darwin
var a = [1,2,3,4,5,6,7]
func shuffle<ItemType>(item1: ItemType, item2: ItemType) -> Bool {
return drand48() > 0.5
}
sort(a, shuffle)
println(a)
Así es como se hace de la manera más sencilla. import Gamplaykit
a su VC y use el siguiente código. Probado en Xcode 8.
import GameplayKit
let array: NSArray = ["Jock", "Ellie", "Sue Ellen", "Bobby", "JR", "Pamela"]
override func viewDidLoad() {
super.viewDidLoad()
print(array.shuffled())
}
Si desea obtener una cadena aleatoria de una matriz, puede utilizar el siguiente código.
func suffleString() {
let ShuffleArray = array.shuffled()
suffleString.text = ShuffleArray.first as? String
print(suffleString.text!)
}
Con Swift 3, si desea barajar una matriz en su lugar u obtener una nueva matriz barajada de una matriz, AnyIterator
puede ayudarlo. La idea es crear una matriz de índices a partir de su matriz, mezclar esos índices con una AnyIterator
e swap(_:_:)
AnyIterator
swap(_:_:)
y mapear cada elemento de esta instancia de AnyIterator
con el elemento correspondiente de la matriz.
El siguiente código de Playground muestra cómo funciona:
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<Int> = 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"]
Puede refactorizar el código anterior y crear una función shuffled()
dentro de una extensión de Array
para obtener una nueva matriz aleatoria de una matriz:
import Darwin // required for arc4random_uniform
extension Array {
func shuffled() -> Array<Element> {
var indexArray = Array<Int>(indices)
var index = indexArray.endIndex
let indexIterator = AnyIterator<Int> {
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] }
}
}
Uso:
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: []
Como alternativa al código anterior, puede crear una función shuffle()
dentro de una extensión de Array
para mezclar una matriz en su lugar:
import Darwin // required for arc4random_uniform
extension Array {
mutating func shuffle() {
var indexArray = Array<Int>(indices)
var index = indexArray.endIndex
let indexIterator = AnyIterator<Int> {
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] }
}
}
Uso:
var mutatingArray = ["Jock", "Ellie", "Sue Ellen", "Bobby", "JR", "Pamela"]
mutatingArray.shuffle()
print(mutatingArray) // may print ["Sue Ellen", "Pamela", "Jock", "Ellie", "Bobby", "JR"]
Ejemplo simple:
extension Array {
mutating func shuffled() {
for _ in self {
// generate random indexes that will be swapped
var (a, b) = (Int(arc4random_uniform(UInt32(self.count - 1))), Int(arc4random_uniform(UInt32(self.count - 1))))
if a == b { // if the same indexes are generated swap the first and last
a = 0
b = self.count - 1
}
swap(&self[a], &self[b])
}
}
}
var array = [1,2,3,4,5,6,7,8,9,10]
array.shuffled()
print(array) // [9, 8, 3, 5, 7, 6, 4, 2, 1, 10]
En mi caso, tuve algunos problemas de intercambio de objetos en Array. Luego me rasqué la cabeza y voy por reinventar la rueda.
// 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
}
}
Esta es la forma de mezclar una matriz con una semilla en Swift 3.0.
extension MutableCollection where Indices.Iterator.Element == Index {
mutating func shuffle() {
let c = count
guard c > 1 else { return }
for (firstUnshuffled , unshuffledCount) in zip(indices, stride(from: c, to: 1, by: -1)) {
srand48(seedNumber)
let number:Int = numericCast(unshuffledCount)
let r = floor(drand48() * Double(number))
let d: IndexDistance = numericCast(Int(r))
guard d != 0 else { continue }
let i = index(firstUnshuffled, offsetBy: d)
swap(&self[firstUnshuffled], &self[i])
}
}
}
Esta es una versión de la implementación de Nate de Fisher-Yates shuffle para 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
}
}
Los cambios son:
- La restricción
Indices.Iterator.Element == Index
ahora es parte del protocolo deIndices.Iterator.Element == Index
y ya no es necesario imponerla en la extensión. - El intercambio de elementos se debe realizar llamando a
swapAt()
en la colección, compare SE-0173 AgregarMutableCollection.swapAt(_:_:)
. -
Element
es un alias paraIterator.Element
.
Esta respuesta detalla cómo mezclar con un algoritmo rápido y uniforme (Fisher-Yates) en Swift 4.2+ y cómo agregar la misma característica en las distintas versiones anteriores de Swift. La denominación y el comportamiento de cada versión de Swift coinciden con los métodos de clasificación mutantes y no mutantes para esa versión.
Swift 4.2+
shuffle
y el shuffle
son nativos con Swift 4.2. Ejemplo de uso:
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 y 4.1
Estas extensiones agregan un método shuffle()
a cualquier colección mutable (matrices y búferes mutables inseguros) y un método shuffled()
a cualquier secuencia:
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
}
}
Mismo uso que en los ejemplos Swift 4.2 anteriores.
Swift 3
Estas extensiones agregan un método shuffle()
a cualquier colección mutable y un método shuffled()
a cualquier secuencia:
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
}
}
Mismo uso que en los ejemplos Swift 4.2 anteriores.
Swift 2
(lenguaje obsoleto: no puede usar Swift 2.x para publicar en iTunes Connect a partir de julio de 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
}
}
Uso:
[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
(lenguaje obsoleto: no puede usar Swift 1.x para publicar en iTunes Connect a partir de julio de 2018)
shuffle
como un método de matriz mutante
Esta extensión te permitirá mezclar una instancia de Array
mutable en su lugar:
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() // e.g., numbers == [6, 1, 8, 3, 2, 4, 7, 5]
shuffled
como un método de matriz no mutante
Esta extensión te permitirá recuperar una copia aleatoria de una instancia de 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() // e.g., mixedup == [6, 1, 8, 3, 2, 4, 7, 5]
Esto es lo que uso:
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
}
Esto es lo que uso:
import GameplayKit
extension Collection {
func shuffled() -> [Iterator.Element] {
let shuffledArray = (self as? NSArray)?.shuffled()
let outputArray = shuffledArray as? [Iterator.Element]
return outputArray ?? []
}
mutating func shuffle() {
if let selfShuffled = self.shuffled() as? Self {
self = selfShuffled
}
}
}
// Usage example:
var numbers = [1,2,3,4,5]
numbers.shuffle()
print(numbers) // output example: [2, 3, 5, 4, 1]
print([10, "hi", 9.0].shuffled()) // output example: [hi, 10, 9]
Forma el artículo de Fisher-Yates shuffle en Wikipedia
Swift 3.1,4.0
una). Método de lápiz y papel:
func shuffle<T>(_ 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
}
segundo). Método moderno: (versión de Durstenfeld)
func shuffle<T>(_ 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:
una). Método de lápiz y papel:
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
}
}
segundo). Método moderno: (versión de Durstenfeld)
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
}
}
}
Referencia:
/* 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)
}
Nota: También puedes usar una matriz vacía.
Salida:
[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]
Por favor, hágame saber si alguna consulta, la versión de Swift Otros será verificada pronto.
Se detiene en "swap (& self [i], & self [j])" cuando actualizo la versión xCode a 7.4 beta.
error fatal: no se admite el intercambio de una ubicación consigo mismo
Encontré la razón por la que i = j (la función de intercambio explotará)
Así que agrego una condición como abajo
if (i != j){
swap(&list[i], &list[j])
}
YA! Esta bien para mi.
Si desea usar la función simple Swift For loop, use esto ->
var arrayItems = ["A1", "B2", "C3", "D4", "E5", "F6", "G7", "H8", "X9", "Y10", "Z11"]
var shuffledArray = [String]()
for i in 0..<arrayItems.count
{
let randomObject = Int(arc4random_uniform(UInt32(items.count)))
shuffledArray.append(items[randomObject])
items.remove(at: randomObject)
}
print(shuffledArray)
Swift Array con extensión ->
extension Array {
// Order Randomize
mutating func shuffle() {
for _ in 0..<count {
sort { (_,_) in arc4random() < arc4random() }
}
}
}
Solución Swift 3, siguiendo la respuesta de @Nate Cook: (funciona si el índice comienza con 0, vea los comentarios a continuación)
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..<countInt - 1 {
let j = Int(arc4random_uniform(UInt32(countInt - i))) + i
guard i != j else { continue }
swap(&self[i], &self[j])
}
}
}
También puede usar la función de swap
genérico e implementar los mencionados Fisher-Yates:
for idx in 0..<arr.count {
let rnd = Int(arc4random_uniform(UInt32(idx)))
if rnd != idx {
swap(&arr[idx], &arr[rnd])
}
}
o menos detallado:
for idx in 0..<steps.count {
swap(&steps[idx], &steps[Int(arc4random_uniform(UInt32(idx)))])
}
Tomando Nate''s algoritmo Nate''s quería ver cómo se vería esto con Swift 2 y las extensiones de protocolo.
Esto es lo que se me ocurrió.
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
}
}
Ahora, cualquier MutableCollectionType
puede usar estos métodos dado que usa Int
como un Index
Edición: Como se señaló en otras respuestas, Swift 4.2 finalmente agrega la generación de números aleatorios a la biblioteca estándar, completa con la mezcla de matrices.
Sin embargo, la suite GKRandom
/ GKRandomDistribution
en GameplayKit puede seguir siendo útil con el nuevo protocolo RandomNumberGenerator
. Si agrega extensiones a GameplayKit RNG para cumplir con el nuevo protocolo de biblioteca estándar, puede obtener fácilmente:
- RNGs enviables (que pueden reproducir una secuencia "aleatoria" cuando es necesario para la prueba)
- RNGs que sacrifican robustez por velocidad.
- RNGs que producen distribuciones no uniformes.
... y seguir haciendo uso de las nuevas API aleatorias "nativas" en Swift.
El resto de esta respuesta se refiere a dichos RNG y / o su uso en compiladores Swift más antiguos.
Ya hay algunas buenas respuestas aquí, así como algunas buenas ilustraciones de por qué escribir tu propia baraja puede ser propenso a errores si no tienes cuidado.
En iOS 9, macOS 10.11 y tvOS 9 (o posterior), no tienes que escribir el tuyo. Hay una implementación eficiente y correcta de Fisher-Yates en GameplayKit (que, a pesar del nombre, no es solo para juegos).
Si solo quieres un shuffle único:
let shuffled = GKRandomSource.sharedRandom().arrayByShufflingObjects(in: array)
Si quieres poder replicar una mezcla aleatoria o una serie de combinaciones aleatorias, elige y siembra una fuente aleatoria específica; p.ej
let lcg = GKLinearCongruentialRandomSource(seed: mySeedValue)
let shuffled = lcg.arrayByShufflingObjects(in: array)
En iOS 10 / macOS 10.12 / tvOS 10, también hay una sintaxis práctica para barajar a través de una extensión en NSArray
. Por supuesto, eso es un poco incómodo cuando usas un Swift Array
(y pierde su tipo de elemento al volver a Swift):
let shuffled1 = (array as NSArray).shuffled(using: random) // -> [Any]
let shuffled2 = (array as NSArray).shuffled() // use default random source
Pero es bastante fácil hacer un envoltorio Swift que conserve el tipo:
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()
En SWIFT 4
func createShuffledSequenceOfNumbers(max:UInt)->[UInt] {
var array:[UInt]! = []
var myArray:[UInt]! = []
for i in 1...max {
myArray.append(i)
}
for i in 1...max {
array.append(i)
}
var tempArray:[Int]! = []
for index in 0...(myArray.count - 1) {
var isNotFinded:Bool = true
while(isNotFinded){
let randomNumber = arc4random_uniform(UInt32(myArray.count))
let randomIndex = Int(randomNumber)
if(!tempArray.contains(randomIndex)){
tempArray.append(randomIndex)
array[randomIndex] = myArray[index]
isNotFinded = false
}
}
}
return array
}
Swift 4 Mezcla los elementos de una matriz en un bucle for donde i es la proporción de mezcla
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))))
}
}
O con extensión 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
}
}
}
let shuffl = GKRandomSource.sharedRandom().arrayByShufflingObjects(in: arrayObject)