Shuffle array swift 3

Question

Come posso convertire la funzione seguente a swift 3? Attualmente si verifica un errore Binary operator '..<' cannot be applied to operands of type 'Int' and 'Self.IndexDistance'.

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 } 

    for i in 0..<count - 1 { //error takes place here 
     let j = Int(arc4random_uniform(UInt32(count - i))) + i 
     guard i != j else { continue } 
     swap(&self[i], &self[j]) 
    } 
    } 
} 

riferimento: https://stackoverflow.com/a/24029847/5222077

Answer 1

count restituisce un IndexDistance che è il tipo descrive distanza tra due indici di raccolta. IndexDistance è richiesto per essere un SignedInteger, ma non deve essere un Int e può essere diverso da Index. Pertanto non è possibile creare nell'intervallo 0..<count - 1.

Una soluzione è quella di utilizzare startIndex e endIndex anziché 0 e count:

extension MutableCollection where Index == Int { 
    /// Shuffle the elements of `self` in-place. 
    mutating func shuffle() { 
     // empty and single-element collections don't shuffle 
     if count < 2 { return } 

     for i in startIndex ..< endIndex - 1 { 
      let j = Int(arc4random_uniform(UInt32(endIndex - i))) + i 
      if i != j { 
       swap(&self[i], &self[j]) 
      } 
     } 
    } 
} 

Un altro vantaggio è che questo funziona correttamente anche con matrice fette (dove l'indice del primo elemento non è necessariamente zero).

nota che in base al nuovo "Swift API Design Guidelines", shuffle() è il nome "corretto" per un metodo mutante shuffle, e shuffled() per il non-mutanti controparte, che restituisce un array:

extension Collection { 
    /// Return a copy of `self` with its elements shuffled 
    func shuffled() -> [Iterator.Element] { 
     var list = Array(self) 
     list.shuffle() 
     return list 
    } 
} 

Aggiornamento: A (ancora più generale) la versione Swift 3 è stata aggiunta a How do I shuffle an array in Swift? nel frattempo.

---

Per Swift 4 (Xcode 9) si deve sostituire la chiamata alla funzione swap() da una chiamata al metodo della raccolta swapAt(). Inoltre non è più necessario la restrizione del tipo Index:

extension MutableCollection { 
    /// Shuffle the elements of `self` in-place. 
    mutating func shuffle() { 
     // empty and single-element collections don't shuffle 
     if count < 2 { return } 

     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) 
     } 
    } 
} 

Vedi SE-0173 Add MutableCollection.swapAt(_:_:) per ulteriori informazioni su swapAt.

Answer 2

suggerirei semplicemente mischiare array invece di cercare di estendere questa a collezioni in generale:

extension Array { 
    mutating func shuffle() { 
     for i in (0..<self.count).reversed() { 
      let ix1 = i 
      let ix2 = Int(arc4random_uniform(UInt32(i+1))) 
      (self[ix1], self[ix2]) = (self[ix2], self[ix1]) 
     } 
    } 
} 

Answer 3

C'è un pescatore-Yates shuffle GameKit:

import GameKit 
let unshuffledArray = [1,2,3,4] 
let shuffledArray = GKRandomSource.sharedRandom().arrayByShufflingObjects(in: unshuffledArray) 
print(shuffledArray) 

Si può anche passare e memorizzare un seme casuale, in modo da ottenere la stessa sequenza di valori di riordino pseudocasuali ogni volta che si fornire lo stesso seme in caso è necessario ricreare una simulazione.

import GameKit 
let unshuffledArray = [1,2,3,4] 
let randomSource = GKLinearCongruentialRandomSource(seed: 1) 
let shuffledArray = randomSource.arrayByShufflingObjects(in: unshuffledArray) 
//Always [1,4,2,3] 
print(shuffledArray) 

Answer 4

È possibile utilizzare l'estensione NSArray dal quadro GameplayKit per questo:

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]