配列からランダムな要素を選ぶ

配列があり、ランダムに1つの要素を選択したいとします。

これを行う最も簡単な方法は何でしょうか？

明白な方法はでしょう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

配列を作成せず、count> 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])

キャスティングは醜いですが、他の誰かが別の方法を持っているのでない限り、キャスティングは必要だと思います。

ルーカスが言ったことをリッピングして、次のようにArrayクラスの拡張を作成できます。

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

}

でスウィフト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

まず、sの静的randomプロパティを実装しますUnsignedIntegerType。

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

次に、境界をClosedInterval持つsの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))
    }
}

次に（もう少し複雑です）、境界ClosedInterval付きのsの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
    }
}

Swiftの組み込みrandom（）関数も拡張機能に使用できます。

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のサポートがあります。

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

例えば：

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更新するプロジェクトの例を次に示します。SKLabelNodeString

    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]

ランダム性には2つの選択肢があります。GKRandomSourceを参照してください。

GKARC4RandomSourceクラスは、C関数のarc4randomファミリーに用いられるものと同様のアルゴリズムを使用します。（ただし、このクラスのインスタンスは、arc4random関数の呼び出しから独立しています。）

このGKLinearCongruentialRandomSourceクラスは、GKARC4RandomSourceクラスよりも高速ですが、ランダムではないアルゴリズムを使用します。（具体的には、生成された数値の低ビットは高ビットよりも頻繁に繰り返されます。）このソースは、堅牢な予測不能性よりもパフォーマンスが重要な場合に使用します。

このGKMersenneTwisterRandomSourceクラスは、GKARC4RandomSourceクラスよりも低速ですがランダムなアルゴリズムを使用します。このソースは、乱数の使用が繰り返しパターンを示さないことが重要であり、パフォーマンスがそれほど重要でない場合に使用します。

私はGameKitのGKRandomSource.sharedRandom（）を使用するのが最適です。

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

また、それらを一意にしたい場合はを使用できます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のインデックス値でシャッフルされた文字列を返します。

それは基本的に文字列の配列をシャッフルし、合計カウント数のランダムな数のピックを持ち、シャッフルされた配列のランダムなインデックスを返します。