如何在arc4random_uniform()的范围之间创建随机数？

Question

所以我在这个代码中的目标是随机滚动两个骰子,因为我们都知道你的常规骰子只有6个边,所以我导入了Foundation来访问arc4random_uniform(UInt32).我试图使用(1..7)的范围来避免随机获得0,但是返回了一个我不太喜欢的错误.我试着这样做:

dice1 = arc4random_uniform(UInt32(1..7))

然而那又归来了

找不到接受提供的参数的'init'的重载

我希望这是足够的信息,你在那里惊人的debs帮助我:)

请注意我只是在操场上练习快速练习.我不必学习如何做到这一点; 在我开始构建实际的应用程序之前,我只是在修补:D

//imports random number function
import Foundation
//creates data storage for dice roll
var dice1: UInt32 = 0
var dice2: UInt32 = 0
//counter variable
var i = 0
//how many times snake eyes happens
var snakeeyes = 0
 //how many times a double is rolled
var `double` = 0
//rolls dice 100 times
while i < 100{
    //from here
    //sets dice roll

这将返回错误"Range $ T3"无法转换为UInt32

   dice1 = arc4random_uniform(1..7)
   dice2 = arc4random_uniform(1..7)

    //checks for snake eyes
    if dice1 == 1 && dice2 == 1 {
        snakeeyes = snakeeyes + 1

    }
    //checks for doubles
    if dice1 == dice2{
        `double` = `double` + 1
    }
    //increases counter
        i = i + 1
    //to here
}
println("You got Snake Eyes \(snakeeyes) times.")
println("You got Doubles, \(`double`) times.")

Answer 1

我相信你应该这样做

dice1 = arc4random_uniform(6) + 1;

得到范围1 - 6.我不做iOS目标C,也没有任何关于swift语言的知识.随机方法应返回0到5之间的值,+ 1将使其为1到6之间的值.

如果你需要一个介于10到30之间的范围那么就可以了

int random = arc4random_uniform(21) + 10;

Answer 2

我做了一个Int类型的扩展.在操场上测试它,希望这是有用的.它还接受负范围:

extension Int
{
    static func random(range: Range<Int> ) -> Int
    {
        var offset = 0

        if range.startIndex < 0   // allow negative ranges
        {
            offset = abs(range.startIndex)
        }

        let mini = UInt32(range.startIndex + offset)
        let maxi = UInt32(range.endIndex   + offset)

        return Int(mini + arc4random_uniform(maxi - mini)) - offset
    }
}

用得像

var aRandomInt = Int.random(-500...100)  // returns a random number within the given range.

或者将它定义为Range扩展名,如下所示:

extension Range
{
    var randomInt: Int
    {
        get
        {
            var offset = 0

            if (startIndex as Int) < 0   // allow negative ranges
            {
                offset = abs(startIndex as Int)
            }

            let mini = UInt32(startIndex as Int + offset)
            let maxi = UInt32(endIndex   as Int + offset)

            return Int(mini + arc4random_uniform(maxi - mini)) - offset
        }
    }
}

// usage example: get an Int within the given Range:
let nr = (-1000 ... 1100).randomInt

Answer 3

相当多的好答案,但我只是想分享我个人最喜欢的Swift随机数生成函数的正整数:

斯威夫特2

func randomNumber(range: Range<Int> = 1...6) -> Int {
    let min = range.startIndex
    let max = range.endIndex
    return Int(arc4random_uniform(UInt32(max - min))) + min
}

斯威夫特3

这里是Swift 3的快速更新,作为奖励,它现在适用于任何符合SignedInteger协议的值类型 - 对于需要指定Int16,Int32等的核心数据应用程序来说更方便.快速说明,如果你真正需要它的无符号整数以及工作,只是复制那么整个函数替换SignedInteger用UnsignedInteger,并toIntMax()用toUIntMax().

func randomNumber<T : SignedInteger>(inRange range: ClosedRange<T> = 1...6) -> T {
    let length = (range.upperBound - range.lowerBound + 1).toIntMax()
    let value = arc4random().toIntMax() % length + range.lowerBound.toIntMax()
    return T(value)
}

斯威夫特4

由于在Swift 4中删除了toIntMax(),我们现在必须使用不同的方法转换为常见的整数类型.在这个例子中,我使用的Int64足够大,但是如果你使用无符号整数或者有Int128或Int256自定义类型,你应该使用它们.

public func randomNumber<T : SignedInteger>(inRange range: ClosedRange<T> = 1...6) -> T {
    let length = Int64(range.upperBound - range.lowerBound + 1)
    let value = Int64(arc4random()) % length + Int64(range.lowerBound)
    return T(value)
}

另外,对于总随机phile,这是一个从任何Collection类型对象返回随机元素的扩展.请注意,这使用上面的函数来生成索引,因此您需要两者.

extension Collection {
    func randomItem() -> Self.Iterator.Element {
        let count = distance(from: startIndex, to: endIndex)
        let roll = randomNumber(inRange: 0...count-1)
        return self[index(startIndex, offsetBy: roll)]
    }
}

用法

randomNumber()

返回1到6之间的随机数.

randomNumber(50...100)

返回50到100之间的数字.当然,你可以用你喜欢的任何东西替换50和100的值.

Answer 4

根据Swift 4.2,现在很容易获得这样的随机数

let randomDouble = Double.random(in: -7.9...12.8)

let randomIntFrom0To10 = Int.random(in: 0 ..< 10)

有关详细信息,请查看此信息

Answer 5

如果你想我为随机数创建它.这是数字Int和Double,Float的扩展

/**
    Arc Random for Double and Float
*/
public func arc4random <T: IntegerLiteralConvertible> (type: T.Type) -> T {
    var r: T = 0
    arc4random_buf(&r, UInt(sizeof(T)))
    return r
}
public extension Int {
    /**
    Create a random num Int
    :param: lower number Int
    :param: upper number Int
    :return: random number Int
    By DaRkDOG
    */
    public static func random (#lower: Int , upper: Int) -> Int {
        return lower + Int(arc4random_uniform(upper - lower + 1))
    }

}
public extension Double {
    /**
    Create a random num Double
    :param: lower number Double
    :param: upper number Double
    :return: random number Double
    By DaRkDOG
    */
    public static func random(#lower: Double, upper: Double) -> Double {
        let r = Double(arc4random(UInt64)) / Double(UInt64.max)
        return (r * (upper - lower)) + lower
    }
}
public extension Float {
    /**
    Create a random num Float
    :param: lower number Float
    :param: upper number Float
    :return: random number Float
    By DaRkDOG
    */
    public static func random(#lower: Float, upper: Float) -> Float {
        let r = Float(arc4random(UInt32)) / Float(UInt32.max)
        return (r * (upper - lower)) + lower
    }
}

使用 :

let randomNumDouble = Double.random(lower: 0.00, upper: 23.50)
let randomNumInt = Int.random(lower: 56, upper: 992)
let randomNumInt =Float.random(lower: 6.98, upper: 923.09)

Answer 6

迅捷3/4:

func randomNumber(range: ClosedRange<Int> = 1...6) -> Int {
    let min = range.lowerBound
    let max = range.upperBound
    return Int(arc4random_uniform(UInt32(1 + max - min))) + min
}

Answer 7

那是因为arc4random_uniform()定义如下:

func arc4random_uniform(_: UInt32) -> UInt32

它需要一个UInt32作为输入,并吐出一个UInt32.您试图传递一系列值.arc4random_uniform为您提供0和之间的随机数和您传递的数字(仅限于此),因此,例如,您想要找到介于-50和50之间的随机数,就像[-50, 50]您可以使用的那样arc4random_uniform(101) - 50

Answer 8

迅速:

var index = 1 + random() % 6

Answer 9

我修改了@DaRk -_- D0G使用Swift 2.0的答案

/**
Arc Random for Double and Float
*/
public func arc4random <T: IntegerLiteralConvertible> (type: T.Type) -> T {
    var r: T = 0
    arc4random_buf(&r, sizeof(T))
    return r
}
public extension Int {
    /**
    Create a random num Int
    :param: lower number Int
    :param: upper number Int
    :return: random number Int
    By DaRkDOG
    */
    public static func random (lower: Int , upper: Int) -> Int {
        return lower + Int(arc4random_uniform(UInt32(upper - lower + 1)))
    }

}
public extension Double {
    /**
    Create a random num Double
    :param: lower number Double
    :param: upper number Double
    :return: random number Double
    By DaRkDOG
    */
    public static func random(lower: Double, upper: Double) -> Double {
        let r = Double(arc4random(UInt64)) / Double(UInt64.max)
        return (r * (upper - lower)) + lower
    }
}
public extension Float {
    /**
    Create a random num Float
    :param: lower number Float
    :param: upper number Float
    :return: random number Float
    By DaRkDOG
    */
    public static func random(lower: Float, upper: Float) -> Float {
        let r = Float(arc4random(UInt32)) / Float(UInt32.max)
        return (r * (upper - lower)) + lower
    }
}