Как сделать случайное число между диапазоном для arc4random_uniform ()?

поэтому моя цель в этом кодебите состоит в случайном броске двух кубиков, и, как мы все знаем, ваш обычный умирающий имеет только 6 сторон, поэтому я импортировал Foundation для доступа к arc4random_uniform (UInt32). Я попытался использовать диапазон (1..7), чтобы избежать случайного получения 0, однако это привело к ошибке, которую мне не понравилось слишком много. Я пытался это сделать:

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

однако это вернулось

Не удалось найти перегрузку для «init», которая принимает поставленные аргументы

Надеюсь, что для вас достаточно информации для вас, потрясающие дебаты, чтобы помочь мне 🙂

Обратите внимание, что я просто делаю это на игровой площадке, чтобы быстро тренироваться. Не обязательно, чтобы я узнал, как это сделать; это просто я возиться, прежде чем я вникаю в создание реальных приложений: 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, но у меня нет никаких знаний о быстром языке. Случайный метод должен возвращать значение от 0 до 5, а значение + 1 будет иметь значение от 1 до 6.

Если вам нужен диапазон между датами, скажем, 10-30, то просто сделайте

 int random = arc4random_uniform(21) + 10; 

Я сделал расширение типа Int. испытал его на детской площадке, надеюсь, что это полезно. Он также принимает отрицательные диапазоны:

 extension Int { static func random(range: Range ) -> 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. 

или определить его как расширение диапазона как свойство, подобное этому:

 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 для целых положительных чисел:

Swift 2

 func randomNumber(range: Range = 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 и т. Д. В качестве быстрой заметки, если вы действительно нужно, чтобы он работал и с целыми числами без знака, просто скопируйте всю функцию, а затем замените SignedInteger на UnsignedInteger и toIntMax() на toUIntMax() .

 func randomNumber(inRange range: ClosedRange = 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 () в Swift 4, теперь мы должны использовать другое средство преобразования в общий целочисленный тип. В этом примере я использую Int64, который достаточно велик для моих целей, но если вы используете целые числа без знака или имеете собственный тип Int128 или Int256, вы должны использовать их.

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

Еще один, для общего random-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 тем, что вам нравится.

Если вы хотите, я создам это для случайных чисел. это расширение числа Int и Double, Float

 /** Arc Random for Double and Float */ public func arc4random  (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) 

Swift 3/4:

 func randomNumber(range: ClosedRange = 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

Swift:

 var index = 1 + random() % 6 

Я изменил ответ @DaRk -_- D0G на работу со Swift 2.0

 /** Arc Random for Double and Float */ public func arc4random  (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 } 

Ответ всего лишь 1 строка:

 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, теперь легко получить случайное число, подобное этому

 let randomDouble = Double.random(in: -7.9...12.8) let randomIntFrom0To10 = Int.random(in: 0 ..< 10) 

для более подробной информации проверьте это

Я успешно выполнил создание случайного числа, используя следующий код:

 var coin = arc4random_uniform(2) + 1 

Надеюсь, это может вам помочь.

Не уверен, почему здесь никто не распространяет 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 

Быстрое решение Xcode Beta 5. На основании Теда ван Гаалена Ответ.

 extension Int { static func random(range: Range ) -> 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) 

Вероятно, можно найти эту небольшую обновленную версию расширения 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 } 

Не уверен, есть ли способ добавить свойство к обоим типам интервалов одновременно.

Давайте будем гением компьютера.