vacio initialize example arreglos array arrays swift shuffle

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 Swift 4.2 , ahora hay un método tanto para una shuffle como para una shuffle shuffled . Puedes leer más sobre la generación aleatoria y las cosas de matriz here .


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 de Indices.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 Agregar MutableCollection.swapAt(_:_:) .
  • Element es un alias para Iterator.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)