Wie macht man eine Zufallszahl zwischen dem Bereich für arc4random_uniform ()?

Mein Ziel in diesem Codebit ist es also, zufällig zwei Würfel zu würfeln. Wie wir alle wissen, hat Ihr regulärer Würfel nur 6 Seiten. Deshalb habe ich Foundation für den Zugriff auf arc4random_uniform (UInt32) importiert. Ich habe versucht, den Bereich von (1..7) zu verwenden, um zu vermeiden, dass zufällig 0 angezeigt wird. Dies hat jedoch einen Fehler zurückgegeben, den ich nicht besonders genossen habe. Ich habe versucht, dies zu tun:

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

das kehrte jedoch zurück

Es wurde keine Überladung für 'init' gefunden, die die angegebenen Argumente akzeptiert

Ich hoffe, dass dies genug Informationen für Sie sind, um mir zu helfen :)

Bitte beachten Sie, dass ich dies nur auf einem Spielplatz mache, um schnell zu üben. Ich muss nicht unbedingt lernen, wie man das macht. Ich bastele nur, bevor ich mit dem Erstellen tatsächlicher Apps beginne: 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

Dies gibt den Fehler zurück, dass 'Range $ T3' nicht in UInt32 konvertierbar ist

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

Ich glaube du solltest es tun

dice1 = arc4random_uniform(6) + 1;

um den Bereich 1 - 6 zu erreichen. Ich mache weder iOS-Ziel C noch habe ich irgendwelche Kenntnisse in der schnellen Sprache. Die Zufallsmethode sollte einen Wert zwischen 0 und 5 zurückgeben, und + 1 ergibt einen Wert zwischen 1 und 6.

Wenn Sie einen Bereich zwischen 10 und 30 benötigen, tun Sie dies einfach

int random = arc4random_uniform(21) + 10;

Ich habe eine Erweiterung vom Typ Int erstellt. Ich habe es auf dem Spielplatz getestet und hoffe, dass dies nützlich ist. Es werden auch negative Bereiche akzeptiert:

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

benutze wie

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

oder definieren Sie es als Range-Erweiterung als Eigenschaft wie folgt:

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

Einige gute Antworten, aber ich wollte nur meine persönliche Lieblingsfunktion zur Erzeugung von Swift-Zufallszahlen für positive ganze Zahlen teilen:

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

Hier ist ein schnelles Update für Swift 3, und als Bonus funktioniert es jetzt für jeden Werttyp, der dem SignedInteger-Protokoll entspricht - viel praktischer für Kerndatenanwendungen, in denen Int16, Int32 usw. angegeben werden müssen Ich brauche es wirklich, um auch mit vorzeichenlosen Ganzzahlen zu arbeiten. Kopieren Sie einfach die gesamte Funktion und ersetzen Sie sie SignedIntegerdurch UnsignedIntegerund toIntMax()mit 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

Dank der Entfernung von toIntMax () in Swift 4 müssen wir jetzt ein anderes Mittel zum Konvertieren in einen gemeinsamen Integer-Typ verwenden. In diesem Beispiel verwende ich Int64, das für meine Zwecke groß genug ist. Wenn Sie jedoch vorzeichenlose Ganzzahlen verwenden oder einen benutzerdefinierten Int128- oder Int256-Typ haben, sollten Sie diese verwenden.

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

Eine weitere Erweiterung für das gesamte Zufallsphil ist eine Erweiterung, die ein zufälliges Element von einem beliebigen CollectionObjekt zurückgibt . Beachten Sie, dass dies die obige Funktion verwendet, um den Index zu generieren, sodass Sie beide benötigen.

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

Verwendung

randomNumber()

gibt eine Zufallszahl zwischen 1 und 6 zurück.

randomNumber(50...100)

Gibt eine Zahl zwischen 50 und 100 einschließlich zurück. Natürlich können Sie die Werte 50 und 100 durch beliebige Werte ersetzen.

Swift 4.2

Leider ist meine beste StackOverflow-Antwort endlich veraltet. Sie können jetzt einfach Int.random(in: 1 ... 6)eine Zufallszahl in einem bestimmten Bereich generieren. Funktioniert auch für andere Formen von Ganzzahlen und Gleitkommazahlen. Collection - Typen auch jetzt bieten shuffle()und randomElement()Funktionen. Es sind daher keine ausgefallenen Randomisierungsfunktionen mehr erforderlich, es sei denn, Sie möchten einen bestimmten Randomisierertyp verwenden.

Laut Swift 4.2 ist es jetzt einfach, eine solche Zufallszahl zu erhalten

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

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

Weitere Details finden Sie hier

Wenn du willst, erstelle ich das für Zufallszahlen. Dies ist die Erweiterung der Nummern Int und 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
    }
}

VERWENDEN :

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<Int> = 1...6) -> Int {
    let min = range.lowerBound
    let max = range.upperBound
    return Int(arc4random_uniform(UInt32(1 + max - min))) + min
}

Das liegt daran, dass arc4random_uniform () wie folgt definiert ist:

func arc4random_uniform(_: UInt32) -> UInt32

Es nimmt ein UInt32 als Eingabe und spuckt ein UInt32 aus. Sie versuchen, einen Wertebereich zu übergeben. arc4random_uniform gibt Ihnen eine Zufallszahl zwischen 0 und der Zahl, die Sie (ausschließlich) übergeben. Wenn Sie also beispielsweise eine Zufallszahl zwischen -50 und 50 suchen möchten, wie [-50, 50]Sie sie verwenden könntenarc4random_uniform(101) - 50

Ich habe die Antwort von @DaRk -_- D0G geändert, um mit Swift 2.0 zu arbeiten

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

Schnell:

var index = 1 + random() % 6

In kurzer Zeit ...

Dies ist inklusive, ein Anruf random(1,2)gibt eine 1 oder eine 2 zurück. Dies funktioniert auch mit negativen Zahlen.

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

Die Antwort ist nur 1 Zeilencode:

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

Die alternative Lösung ist:

    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
}

Obwohl der Nachteil ist, dass diese Zahl nicht bei 0 beginnen kann.

Seit Swift 4.2:

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

Verwendet wie:

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

Edit: Swift 4.2+ bietet dies jetzt:

(100...200).randomElement()

Es ist für mich idiomatisch zu erweitern 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)))
    }
}

In Benutzung:

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

Ich habe erfolgreich eine Zufallszahl mit dem folgenden Code erstellt:

var coin = arc4random_uniform(2) + 1

Hoffe das kann dir helfen.

Swift 3 Xcode Beta 5 Lösung. Basierend auf Ted van Gaalen Antwort.

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;

hoffe das funktioniert. Zufallszahl zwischen Bereich für arc4random_uniform () machen?

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

Wahrscheinlich findet man diese etwas aktualisierte Version der RangeErweiterung aus Ted van Gaalens Antwort mit Swift 4 / Xcode 9+ nützlich :

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)

Oder diese etwas "hackige" Lösung zur Unterstützung offener und geschlossener Intervalle:

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
}

Ich bin mir nicht sicher, ob es eine Möglichkeit gibt, beiden Intervalltypen gleichzeitig Eigenschaften hinzuzufügen.