¿Cómo se puede hacer un número aleatorio entre el rango para arc4random_uniform ()?

así que mi objective en este código es rodar aleatoriamente dos dados y, como todos sabemos, tu dado regular solo tiene 6 lados, así que importé la Fundación para acceder a arc4random_uniform (UInt32). Intenté usar el rango de (1..7) para evitar obtener 0 al azar, pero eso me devolvió un error que no disfruté demasiado. Traté de hacer esto:

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

sin embargo, eso regresó

No se pudo encontrar una sobrecarga para ‘init’ que acepta los argumentos proporcionados

Espero que esto sea suficiente información para ustedes debs increíbles por ahí para ayudarme 🙂

Tenga en cuenta que estoy haciendo esto en un patio de recreo para practicar rápido. No es imperativo que aprenda a hacer esto; solo estoy retocando antes de saltar a la construcción de aplicaciones reales: 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 

Esto devuelve un error de ‘Rango $ T3’ no es convertible a 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.") 

Creo que deberías hacer

 dice1 = arc4random_uniform(6) + 1; 

para obtener el rango 1 – 6. No hago el objective C de iOS ni tengo ningún conocimiento en lenguaje rápido. El método aleatorio debe devolver un valor entre 0 y 5, y + 1 lo convertirá en un valor entre 1 y 6.

Si necesita un rango entre, por ejemplo, 10 – 30, simplemente haga

 int random = arc4random_uniform(21) + 10; 

He hecho una extensión de tipo Int. probado en el patio de recreo, espero que esto sea útil. También acepta rangos negativos:

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

usar como

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

o defínalo como una extensión de rango como una propiedad como esta:

 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 

Bastantes buenas respuestas, pero solo quería compartir mi función favorita de generación de números aleatorios Swift para enteros positivos:

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

Aquí hay una actualización rápida para Swift 3 y, como beneficio adicional, ahora funciona para cualquier tipo de valor que se ajuste al protocolo SignedInteger, mucho más conveniente para aplicaciones de datos centrales que necesitan especificar Int16, Int32, etc. Como nota rápida, si realmente necesito que trabaje en enteros sin signo también, simplemente copie la función completa y luego reemplace SignedInteger con UnsignedInteger y toIntMax() con 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

Gracias a la eliminación de toIntMax () en Swift 4, ahora tenemos que usar un medio diferente de convertir a un tipo de entero común. En este ejemplo, estoy usando Int64, que es lo suficientemente grande para mis propósitos, pero si usa enteros sin signo o tiene un tipo personalizado Int128 o Int256, debe usarlos.

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

Una más, para el total aleatorio-phile, aquí hay una extensión que devuelve un elemento aleatorio de cualquier objeto de tipo Collection . Tenga en cuenta que usa la función anterior para generar su índice, por lo que necesitará ambos.

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

Uso

 randomNumber() 

devuelve un número aleatorio entre 1 y 6.

 randomNumber(50...100) 

devuelve un número entre 50 y 100 inclusive. Naturalmente, puede reemplazar los valores de 50 y 100 con lo que quiera.

Si quieres, yo creo eso para números aleatorios. esta es la extensión del número Int y Doble, Flotador

 /** 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 } } 

UTILIZAR :

 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 } 

Eso es porque arc4random_uniform () se define de la siguiente manera:

 func arc4random_uniform(_: UInt32) -> UInt32 

Toma un UInt32 como entrada, y escupe un UInt32. Está intentando pasarle un rango de valores. arc4random_uniform te da un número aleatorio entre 0 y el número que lo pasas (exclusivamente), así que si, por ejemplo, quisieras encontrar un número aleatorio entre -50 y 50, como en [-50, 50] podrías usar arc4random_uniform(101) - 50

Rápido:

 var index = 1 + random() % 6 

Modifiqué la respuesta de @DaRk -_- D0G para trabajar con 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 } } 

En veloz …

Esto es inclusivo, llamar al random(1,2) devolverá un 1 o un 2, Esto también funcionará con números negativos.

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

La respuesta es solo un código de línea:

 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 

La solución alternativa es:

  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 } 

Aunque el inconveniente es que ese número no puede comenzar desde 0.

Según Swift 4.2 ahora es fácil obtener un número aleatorio como este

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

para más detalles mira esto

Logré crear un número aleatorio utilizando el siguiente código:

 var coin = arc4random_uniform(2) + 1 

Espero que esto le pueda ayudar.

No estoy seguro de por qué nadie más extiende la 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))) } } 

En uso:

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

Swift 3 Xcode Beta 5 Solution. Basado en Ted van Gaalen Respuesta.

 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;

Espero que esto esté funcionando. hacer un número aleatorio entre el rango para arc4random_uniform ()?

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

Probablemente uno encuentre útil esta versión un poco actualizada de la extensión de Range de la respuesta de Ted van Gaalen usando 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) 

O esta solución un poco "hacky" para admitir intervalos abiertos y cerrados:

 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 } 

No estoy seguro si hay una forma de agregar propiedad a ambos tipos de intervalos simultáneamente.

    Intereting Posts