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

因此，我在这个代码位的目标是随机掷两个骰子，正如我们都知道你的常规骰子只有6面，所以我导入了基础访问 arc4随机 _ 统一(UInt32)。我尝试使用(1。.7)避免随机得到0，然而，返回一个错误，我不喜欢太多。我试着这样做:

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

然后又回来了

找不到接受所提供参数的“ init”的重载

我希望这些信息足以让你们这些优秀的女演员们帮助我:)

请注意，我这样做只是在操场上练习快速。我学习如何做这件事并不是必须的，只是在我开始构建真正的应用程序之前的一些修修补补而已

//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.")
155914 次浏览
小开

这是因为 arc4Random _ united ()的定义如下:

func arc4random_uniform(_: UInt32) -> UInt32

它接受一个 UInt32作为输入，并输出一个 UInt32。您试图向它传递一系列值。Arc4Random _ united 为您提供一个介于0和您传递的数字之间的随机数(独占) ，因此，例如，如果您希望找到一个介于 -50和50之间的随机数，比如在 [-50, 50]中，您可以使用 arc4random_uniform(101) - 50

小开
最佳答案

我觉得你应该这么做

dice1 = arc4random_uniform(6) + 1;

才能达到1-6的射程。我没有 iOS 目标 C，也没有任何关于快速语言的知识。随机方法应该返回一个介于0和5之间的值，而 + 1将使它成为介于1和6之间的值。

如果你需要一个范围之间让说10-30然后只是做

int random = arc4random_uniform(21) + 10;
小开

我做了一个 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
小开

斯威夫特:

var index = 1 + random() % 6
小开

如果你想要我为 随机数字。创建它，这是数字 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)
小开

我用以下代码成功地创建了一个随机数:

var coin = arc4random_uniform(2) + 1

希望这个能帮到你。

小开

不少不错的答案，但我只是想分享我个人最喜欢的正整数的 Swift 随机数生成函数:

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
}

Swift 3

这里是 Swift 3的一个快速更新，作为奖励，它现在适用于符合 SignedInteger 协议的任何值类型——对于需要指定 Int16、 Int32等等的核心数据应用程序来说更加方便。简单地说，如果您确实需要它来处理无符号整数，那么只需复制整个函数，然后用 UnsignedInteger替换 SignedInteger，用 toUIntMax()替换 toIntMax()。

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

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

另外，对于总随机类型，这里有一个从任何 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的值替换为您喜欢的任何值。

Swift 4.2

唉，我最好的 StackOverflow 答案终于被淘汰了。您现在可以简单地使用 Int.random(in: 1 ... 6)在给定的范围内生成一个随机数。也适用于其他形式的整数和浮点数。集合类型现在还提供 shuffle()和 randomElement()函数。因此，不再需要花哨的随机化函数，除非你想使用特定的随机化类型。

小开

我修改了@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
}
}
小开

迅速..。

这是包容性的，调用 random(1,2)将返回1或2，这也适用于负数。

    func random(min: Int, _ max: Int) -> Int {
guard min < max else {return min}
return Int(arc4random_uniform(UInt32(1 + max - min))) + min
}
小开

Swift 3 Xcode Beta 5解决方案。 根据 Ted van Gaalen 的回答。

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


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


let mini = UInt32(range.lowerBound + offset)
let maxi = UInt32(range.upperBound   + offset)


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

斯威夫特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
}
小开

Var range _ FromLimits = arc4Random _ unified ((UPPerBound-LOWerBound) + 1)) + LOWerBound;

小开

答案只有一行代码:

let randomNumber = arc4random_uniform(8999) + 1000 //for 4 digit random number
let randomNumber = arc4random_uniform(899999999) + 100000000 //for 9 digit random number
let randomNumber = arc4random_uniform(89) + 10    //for 2 digit random number
let randomNumber = arc4random_uniform(899) + 100  //for 3 digit random number

另一种解决办法是:

    func generateRandomNumber(numDigits: Int) -> Int{
var place = 1
var finalNumber = 0;
var finanum = 0;
for var i in 0 ..< numDigits {
place *= 10
let randomNumber = arc4random_uniform(10)
finalNumber += Int(randomNumber) * place
finanum = finalNumber / 10
i += 1
}
return finanum
}

虽然缺点是数字不能从0开始。

小开

编辑: Swift 4.2 + 提供了以下内容:

(100...200).randomElement()

对我来说，扩展 Range是惯用的做法:

public extension Range where Bound == Int {
var random: Int {
return lowerBound + Int(arc4random_uniform(UInt32(upperBound - lowerBound)))
}
}


public extension ClosedRange where Bound == Int {
var random: Int {
return lowerBound + Int(arc4random_uniform(UInt32(upperBound - lowerBound + 1)))
}
}

使用中:

let foo = (100..<600).random
小开

希望这是工作。使之间的范围为 arc4随机 _ 统一()的随机数？

var randomNumber = Int(arc4random_uniform(6))
print(randomNumber)
小开

也许有人会发现这个有用的 Range扩展的一个更新版本，这个版本来自 Ted van Gaalen 的答案，使用的是 Swift 4/Xcode 9 + :

extension CountableClosedRange where Bound == Int {
var randomFromRange: Bound {
get {
var offset = 0
if lowerBound < 0 {
offset = abs(lowerBound)
}
let mini = UInt32(lowerBound + offset)
let maxi = UInt32(upperBound + offset)
return Int(mini + arc4random_uniform(maxi - mini)) - offset
}
}
}


let n = (-1000 ... 1000).randomFromRange
print(n)

或者这个有点“粗糙”的解决方案来支持打开和关闭的间隔:

extension CountableRange where Bound == Int {
var randomFromRange: Bound {
return uniformRandom(from: lowerBound, to: upperBound)
}
}


extension CountableClosedRange where Bound == Int {
var randomFromRange: Bound {
return uniformRandom(from: lowerBound, to: upperBound - 1)
}
}


func uniformRandom(from: Int, to: Int) -> Int {
var offset = 0
if from < 0 {
offset = abs(from)
}
let mini = UInt32(from + offset)
let maxi = UInt32(to + offset)
return Int(mini + arc4random_uniform(maxi - mini)) - offset
}

不确定是否有一种方法可以同时向这两种类型的间隔添加属性。

小开

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

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


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

更多细节请查看

小开

自从 Swift 4.2:

Int {
public static func random(in range: ClosedRange<Int>) -> Int
public static func random(in range: Range<Int>) -> Int
}

用法如下:

Int.random(in: 2...10)

提交答案