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

swift random number in range

Question

así que mi objetivo 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.")

Answer 1

Swift 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 2

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<Int> = 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<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

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

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.

Answer 3

Creo que deberías hacer

dice1 = arc4random_uniform(6) + 1;

para obtener el rango 1 - 6. No hago el objetivo 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;

Answer 4

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
    }

Answer 5

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

Answer 6

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

Answer 7

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.

Answer 8

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

var coin = arc4random_uniform(2) + 1

Espero que esto le pueda ayudar.

Answer 9

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

Answer 10

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

Answer 11

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.

Answer 12

Rápido:

var index = 1 + random() % 6

Answer 13

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

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)

Answer 14

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

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

Answer 15

var rangeFromLimits = arc4random_uniform ((UPPerBound - LOWerBound) + 1)) + LOWerBound;

Answer 16

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

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