Obtenez de l'aléatoire des éléments de la matrice en swift

J'ai un tableau comme:

var names: String = [ "Peter", "Steve", "Max", "Sandra", "Roman", "Julia" ]

J'aimerais avoir 3 éléments aléatoires à partir de ce tableau. Je suis venue à partir de C#, mais en swift je ne suis pas sûr où commencer. Je pense que je devrais aléatoire de la matrice d'abord et ensuite choisir les 3 premiers éléments, par exemple?

J'ai essayé de mélanger avec l'extension suivante:

extension Array
{
    mutating func shuffle()
    {
        for _ in 0..<10
        {
            sort { (_,_) in arc4random() < arc4random() }
        }
    }
}

mais il dit ensuite: "'() "n'est pas convertible à" [Int]'" au lieu de "shuffle()".

De sélection d'un certain nombre d'éléments que j'utilise:

var randomPicks = names[0..<4];

qui semble bon jusqu'ici.

Comment shuffle? Ou quelqu'un a une meilleure/plus élégante solution pour cela?

Voir stackoverflow.com/questions/24026510/... pour une meilleure lecture aléatoire de la méthode.
Merci, j'ai utilisé la mutation de la méthode d'extension de la accepté anaswer maintenant pour le battage.
Oui, il y a de mieux/plus élégant solutions: plein de brassage n'est pas optimale si vous avez besoin de 4 éléments aléatoires de 10, ramasser les un par un en coûte seulement 4 arc4random_uniform, mais plein de brassage des coûts 9 arc4random_uniform.
À l'aide de sort à battre comme cela ne fonctionne tout simplement pas. Tri intentionnellement n'a que peu de comparaison possible, et certainement pas assez pour atteindre un décent shuffle.

OriginalL'auteur Patric | 2014-12-02

Xcode 9 • Swift 4

extension Array {
    ///Returns an array containing this sequence shuffled
    var shuffled: Array {
        var elements = self
        return elements.shuffle()
    }
    ///Shuffles this sequence in place
    @discardableResult
    mutating func shuffle() -> Array {
        let count = self.count
        indices.lazy.dropLast().forEach {
            swapAt($0, Int(arc4random_uniform(UInt32(count - $0))) + $0)
        }
        return self
    }
    var chooseOne: Element { return self[Int(arc4random_uniform(UInt32(count)))] }
    func choose(_ n: Int) -> Array { return Array(shuffled.prefix(n)) }
}

Aire de jeux de tests

var alphabet = ["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"]
let shuffledAlphabet = alphabet.shuffled

let letter = alphabet.chooseOne

var numbers = Array(0...9)

let shuffledNumbers = numbers.shuffled
shuffledNumbers                              //[8, 9, 3, 6, 0, 1, 4, 2, 5, 7]

numbers            //[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

numbers.shuffle() //mutate it  [6, 0, 2, 3, 9, 1, 5, 7, 4, 8]

numbers            //[6, 0, 2, 3, 9, 1, 5, 7, 4, 8]

let pick3numbers = numbers.choose(3)  // [8, 9, 2]

Xcode 8.3.1 • Swift 3.1

import UIKit

extension Array {
    ///Returns an array containing this sequence shuffled
    var shuffled: Array {
        var elements = self
        return elements.shuffle()
    }
    ///Shuffles this sequence in place
    @discardableResult
    mutating func shuffle() -> Array {
        let count = self.count
        indices.lazy.dropLast().forEach {
            guard case let index = Int(arc4random_uniform(UInt32(count - $0))) + $0, index != $0 else { return }
            swap(&self[$0], &self[index])
        }
        return self
    }
    var chooseOne: Element { return self[Int(arc4random_uniform(UInt32(count)))] }
    func choose(_ n: Int) -> Array { return Array(shuffled.prefix(n)) }
}

Lorsque j'essaie d'utiliser le indexRandom() la méthode, il soulève l'erreur de compilation en disant: find() n'est pas disponible. Permettez-moi de savoir si c'est toute une méthode personnalisée vous avez oublié de mentionner... je suis en utilisant Xcode 7.
Merci pour la réponse rapide... Mais je pense que vous avez supprimé l'Int extension en raison de laquelle indexRandom() la méthode donnera l'erreur.

OriginalL'auteur Leo Dabus

Ou quelqu'un a une meilleure/plus élégante solution pour cela?

Je ne. Algorithmiquement mieux que l'on a accepté la réponse, qui ne comptent-1 arc4random_uniform opérations pour un plein shuffle, nous pouvons simplement prendre n valeurs dans n arc4random_uniform opérations.

Et en fait, j'ai eu deux façons de faire mieux que l'on a accepté la réponse:

Meilleure solution

extension Array {
    ///Picks `n` random elements (straightforward approach)
    subscript (randomPick n: Int) -> [Element] {
        var indices = [Int](0..<count)
        var randoms = [Int]()
        for _ in 0..<n {
            randoms.append(indices.remove(at: Int(arc4random_uniform(UInt32(indices.count)))))
        }
        return randoms.map { self[$0] }
    }
}

Meilleure solution

La solution suivante est deux fois plus rapide que la précédente.

pour Swift 3.0 et 3.1

extension Array {
    ///Picks `n` random elements (partial Fisher-Yates shuffle approach)
    subscript (randomPick n: Int) -> [Element] {
        var copy = self
        for i in stride(from: count - 1, to: count - n - 1, by: -1) {
            let j = Int(arc4random_uniform(UInt32(i + 1)))
            if j != i {
                swap(&copy[i], &copy[j])
            }
        }
        return Array(copy.suffix(n))
    }
}

pour Swift 3.2 et 4.x

extension Array {
    ///Picks `n` random elements (partial Fisher-Yates shuffle approach)
    subscript (randomPick n: Int) -> [Element] {
        var copy = self
        for i in stride(from: count - 1, to: count - n - 1, by: -1) {
            copy.swapAt(i, Int(arc4random_uniform(UInt32(i + 1))))
        }
        return Array(copy.suffix(n))
    }
}

Utilisation:

let digits = Array(0...9)  //[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
let pick3digits = digits[randomPick: 3]  // [8, 9, 0]

Vous êtes les bienvenus, je vous remercie pour votre algorithme ! Essayé le fix, fonctionne comme un charme. Aussi, j'étais convaincu que j'étais en train de Swift 3.2 (Xcode 8.3.3) Swift version drapeau seule me permet de choisir entre Swift "3" et "non spécifié". Cependant, un rapide rapide-version dans le terminal m'a incité avec un méchant swift 3.1. Dois savoir comment la force Swift 3.2 (Convertir à la dernière swift version n'a pas fait l'affaire). Mais c'est une autre question.

OriginalL'auteur Cœur

Swift 4.1 et au-dessous de

let playlist = ["Nothing Else Matters", "Stairway to Heaven", "I Want to Break Free", "Yesterday"]
let index = Int(arc4random_uniform(UInt32(playlist.count)))
let song = playlist[index]

Swift 4.2 et au-dessus de

if let song = playlist.randomElement() {
  print(song)
} else {
  print("Empty playlist.")
}

OriginalL'auteur Prashant Gaikwad

1

Vous pouvez également utiliser arc4random() il suffit de choisir trois éléments du Tableau. Quelque chose comme ceci:
```
extension Array {
    func getRandomElements() -> (T, T, T) {
        return (self[Int(arc4random()) % Int(count)],
                self[Int(arc4random()) % Int(count)],
                self[Int(arc4random()) % Int(count)])
    }
}

let names = ["Peter", "Steve", "Max", "Sandra", "Roman", "Julia"]
names.getRandomElements()
```
C'est juste un exemple, vous pourriez aussi inclure logique de la fonction pour obtenir un nom différent pour chacun.

(a) Vous obtiendrez modulo biais de là, vous devriez être en utilisant arc4random_uniform; (b) je pense que cela peut tomber en panne la moitié du temps sur les architectures 32 bits, alors que vous êtes en mettant la valeur d'un UInt32 (le retour de arc4random()) en (32 bits signé) Int, résultant en un négatif d'index de tableau; (c) il pourrait en résulter, par exemple, "Pierre", "Steve", "Pierre", comme il n'y a pas de code pour éviter les pics de la même élément.
Ouais, merci pour la réponse, mais ce n'est pas vraiment fait en sorte que seuls les éléments sont retournés une fois (que je n'ai pas d'état directement, mais est ce que je suis à la recherche d')

OriginalL'auteur akshay

Vous pouvez définir une extension sur le Tableau:

extension Array {
    func pick(_ n: Int) -> [Element] {
        guard count >= n else {
            fatalError("The count has to be at least \(n)")
        }
        guard n >= 0 else {
            fatalError("The number of elements to be picked must be positive")
        }

        let shuffledIndices = indices.shuffled().prefix(upTo: n)
        return shuffledIndices.map {self[$0]}
    }
}

[ "Peter", "Steve", "Max", "Sandra", "Roman", "Julia" ].pick(3)

Si la table initiale peut avoir des doublons, et que vous voulez l'unicité de la valeur:

extension Array where Element: Hashable {
    func pickUniqueInValue(_ n: Int) -> [Element] {
        let set: Set<Element> = Set(self)
        guard set.count >= n else {
            fatalError("The array has to have at least \(n) unique values")
        }
        guard n >= 0 else {
            fatalError("The number of elements to be picked must be positive")
        }

        return Array(set.prefix(upTo: set.index(set.startIndex, offsetBy: n)))
    }
}

[ "Peter", "Steve", "Max", "Sandra", "Roman", "Julia" ].pickUniqueInValue(3)

OriginalL'auteur Carpsen90

Vous devez vous connecter pour publier un commentaire.