Wählen Sie ein zufälliges Element aus einem Array

Angenommen, ich habe ein Array und möchte ein Element zufällig auswählen.

Was wäre der einfachste Weg, dies zu tun?

Der offensichtliche Weg wäre array[random index]. Aber vielleicht gibt es so etwas wie Rubins array.sample? Oder wenn nicht, könnte eine solche Methode mithilfe einer Erweiterung erstellt werden?

Swift 4.2 und höher

Der neue empfohlene Ansatz ist eine im Erfassungsprotokoll integrierte Methode : randomElement(). Es wird eine Option zurückgegeben, um den leeren Fall zu vermeiden, gegen den ich zuvor angenommen habe.

let array = ["Frodo", "Sam", "Wise", "Gamgee"]
print(array.randomElement()!) // Using ! knowing I have array.count > 0

Wenn Sie das Array nicht erstellen und nicht garantiert sind, dass die Anzahl> 0 ist, sollten Sie Folgendes tun:

if let randomElement = array.randomElement() { 
    print(randomElement)
}

Swift 4.1 und niedriger

Um Ihre Frage zu beantworten, können Sie dies tun, um eine zufällige Array-Auswahl zu erreichen:

let array = ["Frodo", "sam", "wise", "gamgee"]
let randomIndex = Int(arc4random_uniform(UInt32(array.count)))
print(array[randomIndex])

Die Castings sind hässlich, aber ich glaube, sie sind erforderlich, es sei denn, jemand anderes hat einen anderen Weg.

Nach dem, was Lucas gesagt hat, können Sie eine Erweiterung der Array-Klasse wie folgt erstellen:

extension Array {
    func randomItem() -> Element? {
        if isEmpty { return nil }
        let index = Int(arc4random_uniform(UInt32(self.count)))
        return self[index]
    }
}

Beispielsweise:

let myArray = [1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16]
let myItem = myArray.randomItem() // Note: myItem is an Optional<Int>

Swift 4 Version:

extension Collection where Index == Int {

    /**
     Picks a random element of the collection.

     - returns: A random element of the collection.
     */
    func randomElement() -> Iterator.Element? {
        return isEmpty ? nil : self[Int(arc4random_uniform(UInt32(endIndex)))]
    }

}

In Swift 2.2 kann dies so verallgemeinert werden, dass wir:

UInt.random
UInt8.random
UInt16.random
UInt32.random
UInt64.random
UIntMax.random

// closed intervals:

(-3...3).random
(Int.min...Int.max).random

// and collections, which return optionals since they can be empty:

(1..<4).sample
[1,2,3].sample
"abc".characters.sample
["a": 1, "b": 2, "c": 3].sample

Implementieren der statischen randomEigenschaft für UnsignedIntegerTypes:

import Darwin

func sizeof <T> (_: () -> T) -> Int { // sizeof return type without calling
    return sizeof(T.self)
}

let ARC4Foot: Int = sizeof(arc4random)

extension UnsignedIntegerType {
    static var max: Self { // sadly `max` is not required by the protocol
        return ~0
    }
    static var random: Self {
        let foot = sizeof(Self)
        guard foot > ARC4Foot else {
            return numericCast(arc4random() & numericCast(max))
        }
        var r = UIntMax(arc4random())
        for i in 1..<(foot / ARC4Foot) {
            r |= UIntMax(arc4random()) << UIntMax(8 * ARC4Foot * i)
        }
        return numericCast(r)
    }
}

Dann für ClosedIntervals mit UnsignedIntegerTypeGrenzen:

extension ClosedInterval where Bound : UnsignedIntegerType {
    var random: Bound {
        guard start > 0 || end < Bound.max else { return Bound.random }
        return start + (Bound.random % (end - start + 1))
    }
}

Dann (etwas komplizierter) für ClosedIntervals mit SignedIntegerTypeGrenzen (unter Verwendung der weiter unten beschriebenen Hilfsmethoden):

extension ClosedInterval where Bound : SignedIntegerType {
    var random: Bound {
        let foot = sizeof(Bound)
        let distance = start.unsignedDistanceTo(end)
        guard foot > 4 else { // optimisation: use UInt32.random if sufficient
            let off: UInt32
            if distance < numericCast(UInt32.max) {
                off = UInt32.random % numericCast(distance + 1)
            } else {
                off = UInt32.random
            }
            return numericCast(start.toIntMax() + numericCast(off))
        }
        guard distance < UIntMax.max else {
            return numericCast(IntMax(bitPattern: UIntMax.random))
        }
        let off = UIntMax.random % (distance + 1)
        let x = (off + start.unsignedDistanceFromMin).plusMinIntMax
        return numericCast(x)
    }
}

... wo unsignedDistanceTo, unsignedDistanceFromMinund plusMinIntMaxHilfsmethoden können wie folgt umgesetzt werden:

extension SignedIntegerType {
    func unsignedDistanceTo(other: Self) -> UIntMax {
        let _self = self.toIntMax()
        let other = other.toIntMax()
        let (start, end) = _self < other ? (_self, other) : (other, _self)
        if start == IntMax.min && end == IntMax.max {
            return UIntMax.max
        }
        if start < 0 && end >= 0 {
            let s = start == IntMax.min ? UIntMax(Int.max) + 1 : UIntMax(-start)
            return s + UIntMax(end)
        }
        return UIntMax(end - start)
    }
    var unsignedDistanceFromMin: UIntMax {
        return IntMax.min.unsignedDistanceTo(self.toIntMax())
    }
}

extension UIntMax {
    var plusMinIntMax: IntMax {
        if self > UIntMax(IntMax.max) { return IntMax(self - UIntMax(IntMax.max) - 1) }
        else { return IntMax.min + IntMax(self) }
    }
}

Schließlich für alle Sammlungen, in denen Index.Distance == Int:

extension CollectionType where Index.Distance == Int {
    var sample: Generator.Element? {
        if isEmpty { return nil }
        let end = UInt(count) - 1
        let add = (0...end).random
        let idx = startIndex.advancedBy(Int(add))
        return self[idx]
    }
}

... die ein wenig für ganze RangeZahlen optimiert werden kann :

extension Range where Element : SignedIntegerType {
    var sample: Element? {
        guard startIndex < endIndex else { return nil }
        let i: ClosedInterval = startIndex...endIndex.predecessor()
        return i.random
    }
}

extension Range where Element : UnsignedIntegerType {
    var sample: Element? {
        guard startIndex < endIndex else { return nil }
        let i: ClosedInterval = startIndex...endIndex.predecessor()
        return i.random
    }
}

Sie können auch die integrierte Funktion random () von Swift für die Erweiterung verwenden:

extension Array {
    func sample() -> Element {
        let randomIndex = Int(rand()) % count
        return self[randomIndex]
    }
}

let array = [1, 2, 3, 4]

array.sample() // 2
array.sample() // 2
array.sample() // 3
array.sample() // 3

array.sample() // 1
array.sample() // 1
array.sample() // 3
array.sample() // 1

Ein weiterer Vorschlag von Swift 3

private extension Array {
    var randomElement: Element {
        let index = Int(arc4random_uniform(UInt32(count)))
        return self[index]
    }
}

Folgende andere antworten aber mit Swift 2 Unterstützung.

Swift 1.x.

extension Array {
    func sample() -> T {
        let index = Int(arc4random_uniform(UInt32(self.count)))
        return self[index]
    }
}

Swift 2.x.

extension Array {
    func sample() -> Element {
        let index = Int(arc4random_uniform(UInt32(self.count)))
        return self[index]
    }
}

Z.B:

let arr = [2, 3, 5, 7, 9, 11, 13, 17, 19, 23, 29, 31]
let randomSample = arr.sample()

Eine alternative funktionale Implementierung mit Überprüfung auf leeres Array.

func randomArrayItem<T>(array: [T]) -> T? {
  if array.isEmpty { return nil }
  let randomIndex = Int(arc4random_uniform(UInt32(array.count)))
  return array[randomIndex]
}

randomArrayItem([1,2,3])

Hier ist eine Erweiterung für Arrays mit einer leeren Array-Prüfung für mehr Sicherheit:

extension Array {
    func sample() -> Element? {
        if self.isEmpty { return nil }
        let randomInt = Int(arc4random_uniform(UInt32(self.count)))
        return self[randomInt]
    }
}

Sie können es so einfach verwenden :

let digits = Array(0...9)
digits.sample() // => 6

Wenn Sie ein Framework bevorzugen , das auch einige weitere praktische Funktionen bietet, lesen Sie HandySwift . Sie können es über Karthago zu Ihrem Projekt hinzufügen und dann genau wie im obigen Beispiel verwenden:

import HandySwift    

let digits = Array(0...9)
digits.sample() // => 8

Zusätzlich enthält es eine Option, um mehrere zufällige Elemente gleichzeitig abzurufen :

digits.sample(size: 3) // => [8, 0, 7]

Swift 3

GameKit importieren

func getRandomMessage() -> String {

    let messages = ["one", "two", "three"]

    let randomNumber = GKRandomSource.sharedRandom().nextInt(upperBound: messages.count)

    return messages[randomNumber].description

}

Swift 3 - einfach einfach zu bedienen.

1. Array erstellen

   var arrayOfColors = [UIColor.red, UIColor.yellow, UIColor.orange, UIColor.green]

2. Erstellen Sie eine zufällige Farbe

   let randomColor = arc4random() % UInt32(arrayOfColors.count)

3. Stellen Sie diese Farbe auf Ihr Objekt ein

   your item = arrayOfColors[Int(randomColor)]

Hier ist ein Beispiel aus einem SpriteKitProjekt, das a SKLabelNodemit einem Zufall aktualisiert String:

    let array = ["one","two","three","four","five"]

    let randomNumber = arc4random() % UInt32(array.count)

    let labelNode = SKLabelNode(text: array[Int(randomNumber)])

Wenn Sie in der Lage sein möchten, mehr als ein zufälliges Element ohne Duplikate aus Ihrem Array herauszuholen, bietet GameplayKit Folgendes:

import GameplayKit
let array = ["one", "two", "three", "four"]

let shuffled = GKMersenneTwisterRandomSource.sharedRandom().arrayByShufflingObjects(in: array)

let firstRandom = shuffled[0]
let secondRandom = shuffled[1]

Sie haben einige Möglichkeiten für die Zufälligkeit, siehe GKRandomSource :

Das GKARC4RandomSource Klasse verwendet einen Algorithmus ähnlich dem in der arc4random-Familie von C-Funktionen verwendeten. (Instanzen dieser Klasse sind jedoch unabhängig von Aufrufen der arc4random-Funktionen.)

Die GKLinearCongruentialRandomSourceKlasse verwendet einen Algorithmus, der schneller, aber weniger zufällig ist als die GKARC4RandomSource-Klasse. (Insbesondere wiederholen sich die niedrigen Bits der generierten Zahlen häufiger als die hohen Bits.) Verwenden Sie diese Quelle, wenn die Leistung wichtiger ist als die robuste Unvorhersehbarkeit.

Die GKMersenneTwisterRandomSourceKlasse verwendet einen Algorithmus, der langsamer, aber zufälliger ist als die GKARC4RandomSource-Klasse. Verwenden Sie diese Quelle, wenn es wichtig ist, dass Ihre Verwendung von Zufallszahlen keine sich wiederholenden Muster zeigt und die Leistung weniger wichtig ist.

Ich finde, dass die Verwendung von GKRandomSource.sharedRandom () von GameKit am besten für mich funktioniert.

import GameKit

let array = ["random1", "random2", "random3"]

func getRandomIndex() -> Int {
    let randomNumber = GKRandomSource.sharedRandom().nextIntWithUpperBound(array.count)
    return randomNumber

oder Sie können das Objekt an dem ausgewählten Zufallsindex zurückgeben. Stellen Sie sicher, dass die Funktion zuerst einen String zurückgibt und dann den Index des Arrays zurückgibt.

    return array[randomNumber]

Kurz und auf den Punkt.

Derzeit gibt es eine integrierte Methode Collection:

let foods = ["🍕", "🍔", "🍣", "🍝"]
let myDinner = foods.randomElement()

Wenn Sie bis zu nzufällige Elemente aus einer Sammlung extrahieren möchten, können Sie eine Erweiterung wie die folgende hinzufügen:

extension Collection {
    func randomElements(_ count: Int) -> [Element] {
        var shuffledIterator = shuffled().makeIterator()
        return (0..<count).compactMap { _ in shuffledIterator.next() }
    }
}

Und wenn Sie möchten, dass sie eindeutig sind, können Sie a verwenden Set, aber die Elemente der Sammlung müssen dem HashableProtokoll entsprechen:

extension Collection where Element: Hashable {
    func randomUniqueElements(_ count: Int) -> [Element] {
        var shuffledIterator = Set(shuffled()).makeIterator()
        return (0..<count).compactMap { _ in shuffledIterator.next() }
    }
}

Der neueste swift3-Code funktioniert einwandfrei

 let imagesArray = ["image1.png","image2.png","image3.png","image4.png"]

        var randomNum: UInt32 = 0
        randomNum = arc4random_uniform(UInt32(imagesArray.count))
        wheelBackgroundImageView.image = UIImage(named: imagesArray[Int(randomNum)])

Mit den in Swift 4.2 eingeführten neuen Funktionen habe ich einen ganz anderen Weg gefunden.

// 👇🏼 - 1 
public func shufflePrintArray(ArrayOfStrings: [String]) -> String {
// - 2 
       let strings = ArrayOfStrings
//- 3
       var stringans =  strings.shuffled()
// - 4
        var countS = Int.random(in: 0..<strings.count)
// - 5
        return stringans[countS] 
}

1. Wir haben eine Funktion mit Parametern deklariert, die ein Array von Strings nehmen und einen String zurückgeben.

2. Dann nehmen wir die ArrayOfStrings in eine Variable.

3. Dann rufen wir die Shuffled-Funktion auf und speichern sie in einer Variablen. (Wird nur in 4.2 unterstützt)
4. Dann deklarieren wir eine Variable, die einen gemischten Wert der Gesamtanzahl des Strings speichert.
5. Zuletzt geben wir die gemischte Zeichenfolge mit dem Indexwert von countS zurück.

Es mischt im Grunde das Array von Strings und hat dann auch eine zufällige Auswahl der Anzahl der Gesamtzahl der Zählungen und gibt dann den zufälligen Index des gemischten Arrays zurück.