所以我在这个代码中的目标是随机滚动两个骰子，因为我们都知道你的常规骰子只有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.")
我相信你应该这样做
dice1 = arc4random_uniform(6) + 1;
得到范围1 - 6.我不做iOS目标C，也没有任何关于swift语言的知识。随机方法应返回0到5之间的值，+ 1将使其为1到6之间的值。
如果你需要一个介于10到30之间的范围那么就可以了
int random = arc4random_uniform(21) + 10;
在迅速......
这是包容性的，调用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
}
答案只是一行代码：
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开始。
我使用以下代码成功完成了创建随机数：
var coin = arc4random_uniform(2) + 1
希望这可以帮到你。
自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)
编辑：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
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
}
}
var rangeFromLimits = arc4random_uniform（（UPPerBound - LOWerBound）+ 1））+ LOWerBound;
希望这是有效的。在arc4random_uniform（）的范围之间设置随机数？
var randomNumber = Int(arc4random_uniform(6))
print(randomNumber)
可能有人发现使用Swift 4 / Xcode 9+从Ted van Gaalen回答Range扩展的更新版本：
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)
或者这是一个支持开放和封闭间隔的“hacky”解决方案：
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
}
不确定是否有办法同时向两种类型的间隔添加属性。
我做了一个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
相当多的好答案，但我只想分享我个人最喜欢的Swift随机数生成函数的正整数：
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的快速更新，作为奖励，它现在适用于任何符合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)
}
由于在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的值。
唉，我最好的StackOverflow答案终于被淘汰了。您现在可以使用简单的Int.random(in: 1 ... 6)生成给定范围内的随机数。也适用于其他形式的整数和浮点数。集合类型现在还提供shuffle()和randomElement()函数。因此，除非您想使用特定的随机函数类型，否则不再需要花哨的随机函数。
根据Swift 4.2，现在很容易获得这样的随机数
let randomDouble = Double.random(in: -7.9...12.8)
let randomIntFrom0To10 = Int.random(in: 0 ..< 10)
如果你想我为随机数创建它。这是数字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)
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
}
那是因为arc4random_uniform（）定义如下：
func arc4random_uniform(_: UInt32) -> UInt32
它需要一个UInt32作为输入，并吐出一个UInt32。您试图传递一系列值。 arc4random_uniform给出一个介于0和之间的随机数和你传递的数字（独占），所以如果你想找到介于-50和50之间的随机数，就像在[-50, 50]中你可以使用arc4random_uniform(101) - 50
迅速：
var index = 1 + random() % 6
我修改了@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
}
}