स्विफ्ट के साथ यादृच्छिक संख्या उत्पन्न करना

Question

मुझे एक यादृच्छिक संख्या उत्पन्न करने की आवश्यकता है।

ऐसा प्रतीत होता है कि arc4randomफ़ंक्शन अब फ़ंक्शन के साथ भी मौजूद नहीं है arc4random_uniform।

विकल्प मेरे पास हैं arc4random_stir(), arc4random_buf(UnsafeMutablePointer<Void>, Int)और arc4random_addrandom(UnsafeMutablePointer<UInt8>, Int32)।

मुझे फ़ंक्शंस पर कोई डॉक्स नहीं मिल सकता है और हेडर फ़ाइलों में कोई टिप्पणी संकेत नहीं देती है।

Comments

ऐसा प्रतीत होगा कि Xcode में ऑटो-पूर्ण बस टूट गया था। मैं शपथ ले सकता था मैंने इसे ऑटो-पूर्ण के बिना टाइप किया और यह संकलन नहीं किया। अभी व्यस्त हूँ। @Arsen द्वारा अच्छा संदर्भ

— Big_Mac

arc4random_uniform उपलब्ध है। यह फाउंडेशन एपीआई का हिस्सा है, न कि भाषा का मूल हिस्सा, इसलिए आपको इसे उपलब्ध कराने के लिए फ़ाइल के शीर्ष पर "आयात फाउंडेशन" (या "आयात UIKit") की आवश्यकता है।

— विंस ओ'सुल्लिवन

प्रायिकता = Int (arc4random_uniform (UInt32 (कुल))) - क्योंकि टंकणिका टूटी हुई है, टाइपिंग शिकायतें गैर-विशिष्ट थीं, यही मेरी कास्टिंग की शिकायत दो अलग-अलग त्रुटियों से आ रही थी

— bshirley

Answer 1

===== स्विफ्ट 4.2 / Xcode 10 =====

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

// if you want to get a random element in an array
let greetings = ["hey", "hi", "hello", "hola"]
greetings.randomElement()

हुड स्विफ्ट के तहत arc4random_bufकाम पाने के लिए उपयोग करता है।

===== स्विफ्ट 4.1 / Xcode 9 =====

arc4random()0 से 4 294 967 295 की सीमा में एक यादृच्छिक संख्या देता है

drand48()0.0 से 1.0 की सीमा में एक यादृच्छिक संख्या देता है

arc4random_uniform(N)0 से N - 1 की सीमा में एक यादृच्छिक संख्या देता है

उदाहरण:

arc4random() // => UInt32 = 2739058784
arc4random() // => UInt32 = 2672503239
arc4random() // => UInt32 = 3990537167
arc4random() // => UInt32 = 2516511476
arc4random() // => UInt32 = 3959558840

drand48() // => Double = 0.88642843322303122
drand48() // => Double = 0.015582849408328769
drand48() // => Double = 0.58409022031727176
drand48() // => Double = 0.15936862653180484
drand48() // => Double = 0.38371587480719427

arc4random_uniform(3) // => UInt32 = 0
arc4random_uniform(3) // => UInt32 = 1
arc4random_uniform(3) // => UInt32 = 0
arc4random_uniform(3) // => UInt32 = 1
arc4random_uniform(3) // => UInt32 = 2

arc4random_uniform () के निर्माण की सिफारिश की जाती है जैसे arc4random() % upper_boundकि यह "modulo bias" से बचा जाता है जब ऊपरी बाध्य दो की शक्ति नहीं होती है।

Comments

Float.random()वर्तमान में बीटा चिह्नित है , और इसलिए देता है'Float' has no member 'random'

— डेल

Answer 2

आप भी कोशिश कर सकते हैं:

let diceRoll = Int(arc4random_uniform(UInt32(6)))

मुझे इसे काम करने के लिए "UInt32" जोड़ना पड़ा।

Comments

जब मैं इस फंक्शन को देखता हूं तो देखता हूं public func arc4random_uniform(_: UInt32) -> UInt32। इसलिए मैं सोच रहा हूं कि पैरामीटर को क्यों कन्वर्ट किया जाए UInt32? क्या यहां कुछ और हो रहा है?

— मार्क Moeykens

Answer 3

बस इस फ़ंक्शन को कॉल करें और न्यूनतम और अधिकतम संख्या प्रदान करें और आपको एक यादृच्छिक संख्या मिलेगी।

उदाहरण के लिए। randomNumber (MIN: 0, MAX: 10) और आपको 0 से 9 के बीच नंबर मिलेगा ।

func randomNumber(MIN: Int, MAX: Int)-> Int{
    return Int(arc4random_uniform(UInt32(MAX-MIN)) + UInt32(MIN));
}

नोट: - आपको हमेशा आउटपुट एक इंटेगर नंबर मिलेगा।

Comments

मुझे लगता है कि होना चाहिए: func randomNumber(MIN: Int, MAX: Int)-> Int{ return Int(arc4random_uniform(UInt32(MAX-MIN)) + UInt32(MIN)); }

— Adahus

Answer 4

कुछ जाँच के बाद मैंने यह लिखा:

import Foundation

struct Math {
   private static var seeded = false

   static func randomFractional() -> CGFloat {

      if !Math.seeded {
         let time = Int(NSDate().timeIntervalSinceReferenceDate)
         srand48(time)
         Math.seeded = true
      }

      return CGFloat(drand48())
   }
}

अब आप केवल Math.randomFraction()रैंडम नंबर प्राप्त करने के लिए कर सकते हैं [0..1] बिना पहले याद किए। आशा है कि यह किसी की मदद करता है: ओ)

Answer 5

तेजी के साथ अद्यतन 4.2:

let randomInt = Int.random(in: 1..<5)
let randomFloat = Float.random(in: 1..<10)
let randomDouble = Double.random(in: 1...100)
let randomCGFloat = CGFloat.random(in: 1...1000)

Answer 6

एक अन्य विकल्प xorshift128plus एल्गोरिथ्म का उपयोग करना है:

func xorshift128plus(seed0 : UInt64, _ seed1 : UInt64) -> () -> UInt64 {
    var state0 : UInt64 = seed0
    var state1 : UInt64 = seed1
    if state0 == 0 && state1 == 0 {
        state0 = 1 // both state variables cannot be 0
    }

    func rand() -> UInt64 {
        var s1 : UInt64 = state0
        let s0 : UInt64 = state1
        state0 = s0
        s1 ^= s1 << 23
        s1 ^= s1 >> 17
        s1 ^= s0
        s1 ^= s0 >> 26
        state1 = s1
        return UInt64.addWithOverflow(state0, state1).0
    }

    return rand
}

इस एल्गोरिथ्म की अवधि 2 ^ 128 - 1 है और बिग क्रश परीक्षण सूट के सभी परीक्षणों को पारित करता है । ध्यान दें कि जबकि यह एक लंबी अवधि के साथ एक उच्च-गुणवत्ता वाला छद्म यादृच्छिक संख्या जनरेटर है, यह क्रिप्टोग्राफिक रूप से सुरक्षित रैंडम जनरेटर नहीं है ।

आप इसे वर्तमान समय या एन्ट्रापी के किसी अन्य यादृच्छिक स्रोत से प्राप्त कर सकते हैं। उदाहरण के लिए, यदि आपके पास कोई फ़ंक्शन है जिसे urand64()रीड ए UInt64से पढ़ा जाता है /dev/urandom, तो आप इसे इस तरह से उपयोग कर सकते हैं:

let rand = xorshift128plus(urand64(), urand64())
for _ in 1...10 {
    print(rand())
}

Answer 7

let MAX : UInt32 = 9
let MIN : UInt32 = 1 
func randomNumber()
{
   var random_number = Int(arc4random_uniform(MAX) + MIN)
   print ("random = ", random_number);    
}

Comments

आप इस कोड के लिए स्पष्टीकरण क्यों नहीं देते हैं?

— सुधार हुआ

Answer 8

स्विफ्ट 3 में:

यह 0 से सीमा के बीच यादृच्छिक संख्या उत्पन्न करेगा

let limit : UInt32 = 6
print("Random Number : \(arc4random_uniform(limit))")

Comments

और अगर मैं 5 से 10 तक एक यादृच्छिक संख्या उत्पन्न करना चाहता हूं, तो 0 से n संख्या तक नहीं

— ऋषि

@ ऋषि 5 से 10 बजे तकarc4random_uniform(6) + 5

— मैट ले

Answer 9

एक इंट एक्सटेंशन के रूप में मेरा कार्यान्वयन। रेंज में यादृच्छिक संख्या उत्पन्न करेगाfrom..<to

public extension Int {
    static func random(from: Int, to: Int) -> Int {
        guard to > from else {
            assertionFailure("Can not generate negative random numbers")
            return 0
        }
        return Int(arc4random_uniform(UInt32(to - from)) + UInt32(from))
    }
}

Answer 10

इस तरह से मुझे 2 int के बीच एक यादृच्छिक संख्या मिलती है!

func randomNumber(MIN: Int, MAX: Int)-> Int{
    var list : [Int] = []
    for i in MIN...MAX {
        list.append(i)
    }
    return list[Int(arc4random_uniform(UInt32(list.count)))]
}

उपयोग:

print("My Random Number is: \(randomNumber(MIN:-10,MAX:10))")

Answer 11

एक और विकल्प गेमकिट से GKMersenneTwisterRandomSource का उपयोग करना है। डॉक्स कहते हैं:

एक नियतात्मक छद्म यादृच्छिक स्रोत जो एक mersenne ट्विस्टर एल्गोरिथ्म के आधार पर यादृच्छिक संख्या उत्पन्न करता है। यह विश्वसनीय गेमप्ले यांत्रिकी बनाने के लिए उपयुक्त एक निर्धारक यादृच्छिक स्रोत है। यह एक आर्क 4 स्रोत की तुलना में थोड़ा धीमा है, लेकिन अधिक यादृच्छिक, इसमें अनुक्रमों को दोहराने तक एक लंबी अवधि होती है। नियतात्मक होने के दौरान, यह एक क्रिप्टोग्राफिक यादृच्छिक स्रोत नहीं है। हालांकि यह गेमप्ले डेटा के स्थगन के लिए उपयुक्त है।

import GameKit

let minValue = 0
let maxValue = 100

var randomDistribution: GKRandomDistribution?
let randomSource = GKMersenneTwisterRandomSource()
randomDistribution = GKRandomDistribution(randomSource: randomSource, lowestValue: minValue, highestValue: maxValue)
let number = randomDistribution?.nextInt() ?? 0
print(number)

उदाहरण Apple के नमूना कोड से लिया गया: https://github.com/carekit-apple/CareKit/blob/master/CareKitPrototypingTool/OCKPrototyper/CareKitPatient/chenNumberGeneratorHelper.swift

Answer 12

मुझे पार्टी के लिए देर हो रही है 🤩🎉

एक फ़ंक्शन का उपयोग करना जो आपको सरणी के आकार को बदलने की अनुमति देता है और मक्खी पर सीमा का चयन सबसे बहुमुखी विधि है। आप मानचित्र का उपयोग भी कर सकते हैं इसलिए यह बहुत संक्षिप्त है। मैं अपने सभी प्रदर्शन परीक्षण / बेंच मार्किंग में इसका उपयोग करता हूं।

elementsसरणी में आइटमों की संख्या
केवल संख्याओं से शामिल है0...max

func randArr(_ elements: Int, _ max: Int) -> [Int] {
        return (0..<elements).map{ _ in Int.random(in: 0...max) }
    }

कोड सेंस / प्लेसहोल्डर इस तरह दिखते हैं। randArr(elements: Int, max: Int)

मेरे सरणी में 10 तत्व 0 से 1000 तक हैं।

randArr(10, 1000) // [554, 8, 54, 87, 10, 33, 349, 888, 2, 77]

Answer 13

आप इसे विशिष्ट दर में उपयोग कर सकते हैं:

let die = [1, 2, 3, 4, 5, 6]
 let firstRoll = die[Int(arc4random_uniform(UInt32(die.count)))]
 let secondRoll = die[Int(arc4random_uniform(UInt32(die.count)))]

Answer 14

यादृच्छिक संख्या या यादृच्छिक स्ट्रिंग के लिए स्विफ्ट के साथ कोड देता है :)

let quotes: NSArray = ["R", "A", "N", "D", "O", "M"]

      let randomNumber = arc4random_uniform(UInt32(quotes.count))
      let quoteString = quotes[Int(randomNumber)]
      print(quoteString)

यह आपको बेतरतीब ढंग से आउटपुट देगा।

Answer 15

मत भूलो कि कुछ संख्या दोहराएंगे! इसलिए आपको कुछ करने की जरूरत है ...।

मेरी कुल संख्या 47 थी।

func getRandomNumbers(totalQuestions:Int) -> NSMutableArray
{

    var arrayOfRandomQuestions: [Int] = []

    print("arraySizeRequired = 40")
    print("totalQuestions = \(totalQuestions)")

    //This will output a 40 random numbers between 0 and totalQuestions (47)
    while arrayOfRandomQuestions.count < 40
    {

        let limit: UInt32 = UInt32(totalQuestions)

        let theRandomNumber = (Int(arc4random_uniform(limit)))

            if arrayOfRandomQuestions.contains(theRandomNumber)
            {
                print("ping")

            }
            else
            {
            //item not found
                arrayOfRandomQuestions.append(theRandomNumber)
            }

    }

    print("Random Number set = \(arrayOfRandomQuestions)")
    print("arrayOutputCount = \(arrayOfRandomQuestions.count)")


    return arrayOfRandomQuestions as! NSMutableArray

}

Answer 16

देखो, मैं एक ही समस्या थी, लेकिन मैं एक वैश्विक चर के रूप में फ़ंक्शन सम्मिलित करता हूं

जैसा

var RNumber = Int(arc4random_uniform(9)+1)

func GetCase(){

your code
}

स्पष्ट रूप से यह प्रभावोत्पादक नहीं है, इसलिए मैं अभी कोड को फ़ंक्शन में कॉपी और पेस्ट करता हूं ताकि यह पुन: प्रयोज्य हो सके, तो xcode ने मुझे सुझाव दिया कि मैं वेरिएबल को निरंतर सेट करूं ताकि मेरे कोड थे

func GetCase() {

let RNumber = Int(arc4random_uniform(9)+1)

   if categoria == 1 {
    }
}

अच्छी तरह से मेरे कोड का एक हिस्सा है तो xcode मुझे कुछ असाध्य और आरंभीकरण के बारे में बताता है लेकिन, यह वैसे भी ऐप का निर्माण करता है और यह सलाह बस गायब हो जाती है

आशा करता हूँ की ये काम करेगा