เลือกองค์ประกอบแบบสุ่มจากอาร์เรย์

สมมติว่าฉันมีอาร์เรย์และฉันต้องการที่จะเลือกองค์ประกอบหนึ่งโดยการสุ่ม

อะไรจะเป็นวิธีที่ง่ายที่สุดในการทำเช่นนี้?

array[random index]วิธีที่ชัดเจนจะเป็น แต่บางทีอาจจะมีอะไรบางอย่างเช่นทับทิมของarray.sample? หรือหากไม่สามารถสร้างวิธีดังกล่าวโดยใช้ส่วนขยายได้

Swift 4.2 ขึ้นไป

randomElement()วิธีที่แนะนำใหม่จะถูกสร้างขึ้นในวิธีการในการเก็บโปรโตคอล: มันจะส่งคืนตัวเลือกเพื่อหลีกเลี่ยงกรณีที่ว่างเปล่าที่ฉันคาดไว้

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

หากคุณไม่ได้สร้างอาร์เรย์และไม่รับประกันการนับ> 0 คุณควรทำดังนี้:

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

Swift 4.1 และต่ำกว่า

เพียงตอบคำถามของคุณคุณสามารถทำได้เพื่อให้ได้การเลือกอาเรย์แบบสุ่ม:

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

การหล่อนั้นน่าเกลียด แต่ฉันเชื่อว่าพวกมันจำเป็นต้องใช้เว้นแต่จะมีคนอื่นมีวิธีอื่น

การพูดถึงสิ่งที่ลูคัสกล่าวไว้คุณสามารถสร้างส่วนขยายของคลาสอาเรย์เช่นนี้ได้:

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

ตัวอย่างเช่น:

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 :

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

}

ในSwift 2.2สิ่งนี้สามารถทำให้เป็นเรื่องทั่วไปเพื่อที่เราจะได้:

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

ขั้นแรกให้ใช้randomคุณสมบัติแบบคงที่สำหรับ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)
    }
}

จากนั้นสำหรับClosedIntervals ด้วยUnsignedIntegerTypeขอบเขต:

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

จากนั้น (เกี่ยวข้องเล็กน้อย) สำหรับClosedIntervals ที่มีSignedIntegerTypeขอบเขต (ใช้วิธีการช่วยเหลือที่อธิบายไว้ด้านล่าง):

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

... ที่unsignedDistanceTo, unsignedDistanceFromMinและplusMinIntMaxผู้ช่วยวิธีการสามารถดำเนินการดังต่อไปนี้:

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

ในที่สุดสำหรับคอลเลกชันทั้งหมดที่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]
    }
}

... ซึ่งสามารถเพิ่มประสิทธิภาพเล็กน้อยสำหรับจำนวนเต็มRanges:

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

คุณสามารถใช้ฟังก์ชัน random () ในตัวของ Swift ได้เช่นกันสำหรับส่วนขยาย:

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

ข้อเสนอแนะอื่น ๆ ของ Swift 3

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

ทำตามคำตอบของผู้อื่น แต่ด้วยการสนับสนุน Swift 2

สวิฟท์ 1.x

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

สวิฟท์ 2.x

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

เช่น:

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

การประยุกต์ใช้งานทางเลือกพร้อมการตรวจสอบอาเรย์ที่ว่างเปล่า

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

ต่อไปนี้เป็นส่วนขยายของอาร์เรย์ที่มีการตรวจสอบอาร์เรย์ว่างเพื่อความปลอดภัยเพิ่มเติม:

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

คุณสามารถใช้งานได้ง่ายอย่างนี้ :

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

ถ้าคุณชอบกรอบที่ยังมีคุณสมบัติที่มีประโยชน์มากขึ้นบางแล้วเช็คเอาท์HandySwift คุณสามารถเพิ่มลงในโครงการของคุณผ่านทาง Carthageจากนั้นใช้อย่างตรงตามตัวอย่างด้านบน:

import HandySwift    

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

นอกจากนี้ยังมีตัวเลือกในการรับองค์ประกอบสุ่มหลายรายการพร้อมกัน:

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

สวิฟท์ 3

นำเข้า GameKit

func getRandomMessage() -> String {

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

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

    return messages[randomNumber].description

}

Swift 3 - ใช้งานง่ายง่าย

1. สร้างอาร์เรย์

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

2. สร้างสีแบบสุ่ม

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

3. กำหนดสีนั้นให้กับวัตถุของคุณ

   your item = arrayOfColors[Int(randomColor)]

นี่คือตัวอย่างจากSpriteKitโครงการที่อัพเดตSKLabelNodeด้วยการสุ่มString:

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

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

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

หากคุณต้องการที่จะได้รับองค์ประกอบสุ่มมากกว่าหนึ่งรายการจากอาเรย์ของคุณโดยไม่ซ้ำซ้อน GameplayKit ได้ครอบคลุม:

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

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

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

คุณมีสองทางเลือกสำหรับการสุ่มเลือกดูGKRandomSource :

GKARC4RandomSourceชั้นใช้ขั้นตอนวิธีการคล้ายกับว่าการจ้างงานในครอบครัว arc4random ของฟังก์ชั่น C (อย่างไรก็ตามอินสแตนซ์ของคลาสนี้ไม่ขึ้นอยู่กับการเรียกไปยังฟังก์ชัน arc4random)

GKLinearCongruentialRandomSourceระดับใช้อัลกอริทึมที่เร็ว แต่สุ่มน้อยกว่าระดับ GKARC4RandomSource (โดยเฉพาะตัวเลขที่สร้างขึ้นจำนวนน้อยจะทำซ้ำบ่อยกว่าบิตสูง) ใช้แหล่งข้อมูลนี้เมื่อประสิทธิภาพมีความสำคัญมากกว่าความคาดเดาไม่ได้ที่แข็งแกร่ง

GKMersenneTwisterRandomSourceชั้นใช้วิธีการที่จะช้า แต่สุ่มมากขึ้นกว่าระดับ GKARC4RandomSource ใช้แหล่งข้อมูลนี้เมื่อเป็นสิ่งสำคัญที่การใช้ตัวเลขสุ่มของคุณไม่แสดงรูปแบบการทำซ้ำและประสิทธิภาพจะลดความกังวลลง

ฉันพบว่าการใช้ GKRandomSource.sharedRandom () ของ GameKit นั้นดีที่สุดสำหรับฉัน

import GameKit

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

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

หรือคุณสามารถคืนวัตถุที่ดัชนีสุ่มที่เลือก ตรวจสอบให้แน่ใจว่าฟังก์ชั่นส่งกลับสตริงก่อนแล้วจึงส่งกลับดัชนีของอาร์เรย์

    return array[randomNumber]

สั้นและตรงประเด็น

มีวิธีการในตัวในCollectionตอนนี้:

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

หากคุณต้องการแยกnองค์ประกอบแบบสุ่มถึงคอลเลกชันคุณสามารถเพิ่มส่วนขยายเช่นนี้:

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

และถ้าคุณต้องการให้มันไม่เหมือนใครคุณสามารถใช้ a Setได้ แต่องค์ประกอบของคอลเลกชันต้องสอดคล้องกับHashableโปรโตคอล:

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

รหัส swift3 ล่าสุดลองใช้งานได้ดี

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

ฉันหาวิธีที่แตกต่างออกไปมากโดยใช้คุณสมบัติใหม่ที่แนะนำใน Swift 4.2

// 👇🏼 - 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. เราประกาศฟังก์ชั่นที่มีพารามิเตอร์กำลังใช้อาร์เรย์ของสตริงและส่งคืนสตริง

2. จากนั้นเราก็ใช้ ArrayOfStringsในตัวแปร

3. จากนั้นเราเรียกฟังก์ชันการสับและเก็บไว้ในตัวแปร (รองรับเฉพาะใน 4.2)
4. จากนั้นเราจะประกาศตัวแปรที่บันทึกค่าที่สับได้ของจำนวนทั้งหมดของสตริง
5. สุดท้ายเรากลับสตริงแบบสับที่ค่าดัชนีของ countS

โดยทั่วไปแล้วจะมีการสับเปลี่ยนอาร์เรย์ของสตริงและจากนั้นจะมีการสุ่มเลือกจำนวนของจำนวนทั้งหมดของการนับแล้วส่งกลับดัชนีแบบสุ่มของอาร์เรย์แบบสับ