randint - swift random range




Como alguém faz um número aleatório entre o intervalo para arc4random_uniform()? (12)

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
}

então meu objetivo neste codebit é rolar aleatoriamente dois dados e como todos nós sabemos que o seu dado normal tem apenas 6 lados, então eu importei o Foundation para acesso ao arc4random_uniform (UInt32). Eu tentei usar o intervalo de (1..7) para evitar aleatoriamente obter 0 no entanto, que retornou um erro que eu não gostei muito. Eu tentei fazer isso:

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

no entanto, que retornou

Não foi possível encontrar uma sobrecarga para o 'init' que aceita os argumentos fornecidos

Espero que isso seja informação suficiente para você debs incríveis lá fora para me ajudar :)

Por favor, note que eu estou apenas fazendo isso em um playground para praticar rápido. Não é imperativo que eu aprenda como fazer isso; é só eu mexer antes de começar a criar aplicativos reais: 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

Isso retorna um erro de 'Range $ T3' não é convertível para 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.")

A resposta é apenas um código de linha:

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

A solução alternativa é:

    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
}

Embora a desvantagem é que o número não pode começar de 0.


De acordo com o Swift 4.2, agora é fácil obter números aleatórios como este

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

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

para mais detalhes, confira


Desde o Swift 4.2:

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

Usado como:

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

Em rápida ...

Isso é inclusivo, chamando random(1,2) retornará um 1 ou um 2, isso também funcionará com 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
    }

Eu acredito que você deveria fazer

dice1 = arc4random_uniform(6) + 1;

para obter o intervalo 1 - 6. Eu não faço iOS objetivo C nem tenho qualquer conhecimento em linguagem rápida embora. O método aleatório deve retornar um valor entre 0 e 5, e + 1 fará com que seja um valor entre 1 e 6.

Se você precisa de um intervalo entre digamos de 10 a 30, então faça

int random = arc4random_uniform(21) + 10;

Eu modifiquei a resposta do @DaRk -_- D0G para trabalhar com o 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
    }
}

Isso porque arc4random_uniform () é definido da seguinte forma:

func arc4random_uniform(_: UInt32) -> UInt32

Leva um UInt32 como entrada e cospe um UInt32. Você está tentando passar um intervalo de valores. arc4random_uniform fornece um número aleatório entre 0 e o número que você passa (exclusivamente), portanto, por exemplo, você queria encontrar um número aleatório entre -50 e 50, como em [-50, 50] você poderia usar arc4random_uniform(101) - 50


Provavelmente achamos útil esta versão um pouco atualizada da extensão Range da resposta 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)

Ou isso é uma solução "hacky" para suportar intervalos abertos e fechados:

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
}

Não tenho certeza se existe uma maneira de adicionar propriedade aos dois tipos de intervalos simultaneamente.


Rápido:

var index = 1 + random() % 6

Swift 3 Xcode Beta 5 Solution. Baseado na resposta de 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;