Shuffle tableau swift 3

Comment puis-je convertir la fonction ci-dessous pour swift 3? Actuellement, l'obtention d'un Binary operator '..<' cannot be applied to operands of type 'Int' and 'Self.IndexDistance' erreur.

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

référence: https://stackoverflow.com/a/24029847/5222077

InformationsquelleAutor kye | 2016-06-15
  1. 78

    count retourne un IndexDistance qui est le type décrivant
    la distance entre deux de collecte d'indices. IndexDistance est
    requises pour être un SignedInteger, mais n'ont pas besoin d'être un Int et peut
    être différent de Index. Par conséquent, il n'est pas possible de créer
    la gamme 0..<count - 1.

    Une solution est d'utiliser startIndex et endIndex au lieu de 0 et 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 autre avantage est que cela fonctionne aussi correctement avec le tableau tranches
    (où l'indice du premier élément n'est pas nécessairement égale à zéro).

    Note que, selon le nouveau "Swift API lignes Directrices de Conception",
    shuffle() est le "bon" nom d'une mutation aléatoire de la méthode,
    et shuffled() pour la non-mutation homologue qui retourne un tableau:

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

    Mise à jour: Un (encore plus général) de Swift, la version 3 a été ajouté à
    Comment puis-je shuffle un tableau dans Swift? dans l'intervalle.

    Pour Swift 4 (Xcode 9) on doit remplacer l'appel à la swap()
    fonction par un appel à la swapAt() méthode de la collection.
    Aussi la restriction sur le Index type n'est plus nécessaire:

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

    Voir SE-0173 Ajouter MutableCollection.échangerau(_:_:) pour plus d'informations sur swapAt.

    De Swift 4.2 (Xcode 10, actuellement en version bêta), avec la mise en œuvre de
    SE-0202 Aléatoire Unification,
    shuffle() et shuffled() font partie de la Swift de la bibliothèque standard.

    • Vous êtes un génie
    • Juste senti comme je me dois de souligner que le + i dans let j devrait probablement être + startIndex à la place. Le reste c'est très probablement le résultat de l'indice hors limites.
    • Je suis assez sûr que le code ci-dessus est correct, et j'avais testé avec les deux tableaux de tableaux et de tranches. i est dans la gamme startIndex..<endIndex-1, et un nombre aléatoire dans une plage de 0..<endIndex-i est ajouté à i, de sorte que j >= i >= startIndex et j < i + (endIndex-i) = endIndex.
    • Ah, je vois maintenant où j'ai lu votre code de mal. Désolé, il est tôt encore. J'avais lu votre j comme endIndex-1 et pas endIndex-i. 🙂
    • Il me semble que startIndex..<endIndex - 1 devrait être startIndex...endIndex -1 ou startIndex..<endIndex que le second déjà s'arrête et un de moins que endIndex, et le et le premier sans l' - 1 serait aller à endIndex résultant en un Indice hors limites. La façon dont il est écrit dans le bloc de code ne doit jamais toucher le dernier élément du tableau. Ou est ma compréhension de la façon de l' ... et ..< travail incorrect?
    • Si i == endIndex-1 puis j == i serait le seul indice possible de permuter avec, par conséquent, il suffit si i s'exécute jusqu'à endIndex-2
    • OK, ça a du sens. Je viens de vérifier comme venant d'autres langage de programmation faisant la matrice.count-1 si juste presque réflexe, et je dois le rappeler, moi, qu'avec ..< je n'ai pas besoin d'utiliser le -1 de plus.
    • Martin, si possible pouvez-vous prendre un coup d'oeil here

    InformationsquelleAutor Martin R
  2. 10

    Il y a un shuffle de fisher-yates dans Gamekit:

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

    Vous pouvez également transmettre et de stocker une valeur aléatoire, de sorte que vous obtenez de la même séquence pseudo-aléatoire shuffle valeurs à chaque fois que vous offre la même graine dans le cas où vous avez besoin de recréer une simulation.

    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)
    InformationsquelleAutor Josh Homann
  3. 8

    Je suggère simplement de brassage des tableaux au lieu d'essayer de l'étendre à des collections en général:

    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])
        }
    }
}
    InformationsquelleAutor matt
  4. 0

    Vous pouvez utiliser le NSArray Extension de GameplayKit cadre de cette:

    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]
    InformationsquelleAutor Daniel Illescas