c# मैं सी#में एक यादृच्छिक int संख्या कैसे उत्पन्न करूं?




random (18)

मैं सी # में एक यादृच्छिक पूर्णांक कैसे उत्पन्न करूं?


मैं एक क्रिप्टोग्राफिक रूप से सुरक्षित संस्करण जोड़ना चाहता था:

आरएनजीक्रिप्टो सेवा प्रदाता वर्ग ( MSDN या dotnetperls )

यह IDisposable लागू करता है।

using (RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
{
   byte[] randomNumber = new byte[4];//4 for int32
   rng.GetBytes(randomNumber);
   int value = BitConverter.ToInt32(randomNumber, 0);
}

यह वह वर्ग है जिसका मैं उपयोग करता हूं। RandomNumber.GenerateRandom(1, 666) तरह काम करता है

internal static class RandomNumber
{
    private static Random r = new Random();
    private static object l = new object();
    private static Random globalRandom = new Random();
    [ThreadStatic]
    private static Random localRandom;
    public static int GenerateNewRandom(int min, int max)
    {
        return new Random().Next(min, max);
    }
    public static int GenerateLockedRandom(int min, int max)
    {
        int result;
        lock (RandomNumber.l)
        {
            result = RandomNumber.r.Next(min, max);
        }
        return result;
    }
    public static int GenerateRandom(int min, int max)
    {
        Random random = RandomNumber.localRandom;
        if (random == null)
        {
            int seed;
            lock (RandomNumber.globalRandom)
            {
                seed = RandomNumber.globalRandom.Next();
            }
            random = (RandomNumber.localRandom = new Random(seed));
        }
        return random.Next(min, max);
    }
}

here से संशोधित उत्तर।

यदि आपके पास इंटेल सिक्योर कुंजी संगत CPU तक पहुंच है, तो आप इन पुस्तकालयों का उपयोग करके वास्तविक यादृच्छिक संख्याएं और तार उत्पन्न कर सकते हैं: https://github.com/JebteK/RdRand और https://www.rdrand.com/

here से नवीनतम संस्करण डाउनलोड here , Jebtek.RdRand शामिल करें और इसके लिए एक उपयोग कथन जोड़ें। फिर, आपको बस इतना करना है:

bool isAvailable = RdRandom.GeneratorAvailable(); //Check to see if this is a compatible CPU
string key = RdRandom.GenerateKey(10); //Generate 10 random characters
string apiKey = RdRandom.GenerateAPIKey(); //Generate 64 random characters, useful for API keys
byte[] b = RdRandom.GenerateBytes(10); //Generate an array of 10 random bytes
uint i = RdRandom.GenerateUnsignedInt() //Generate a random unsigned int

यदि आपके पास कोड निष्पादित करने के लिए कोई संगत CPU नहीं है, तो बस rdrand.com पर रीस्टफुल सेवाओं का उपयोग करें। आपकी परियोजना में शामिल RdRandom wrapper लाइब्रेरी के साथ, आपको बस ऐसा करने की आवश्यकता होगी (जब आप साइन अप करते हैं तो आपको 1000 निःशुल्क कॉल मिलती हैं):

string ret = Randomizer.GenerateKey(<length>, "<key>");
uint ret = Randomizer.GenerateUInt("<key>");
byte[] ret = Randomizer.GenerateBytes(<length>, "<key>");

आप MiscUtil क्लास लाइब्रेरी के अंदर जॉन स्कीट की StaticRandom विधि का उपयोग कर सकते हैं जिसे उन्होंने छद्म-यादृच्छिक संख्या के लिए बनाया था।

using System;
using MiscUtil;

class Program
{
    static void Main(string[] args)
    {
        for (int i = 0; i < 100; i++)
        {
            Console.WriteLine(StaticRandom.Next());
        }
    }
}

सावधान रहें कि new Random() वर्तमान टाइमस्टैम्प पर बीजित है।

यदि आप केवल एक नंबर उत्पन्न करना चाहते हैं तो आप इसका उपयोग कर सकते हैं:

new Random().Next( int.MinValue, int.MaxValue )

अधिक जानकारी के लिए, Random वर्ग देखें, हालांकि कृपया ध्यान दें:

हालांकि, क्योंकि घड़ी में सीमित संकल्प है, पैरामीटर रहित कन्स्ट्रक्टर का उपयोग करीबी उत्तराधिकार में विभिन्न रैंडम ऑब्जेक्ट्स बनाने के लिए यादृच्छिक संख्या जेनरेटर बनाता है जो यादृच्छिक संख्याओं के समान अनुक्रम उत्पन्न करता है

तो यादृच्छिक संख्या की एक श्रृंखला उत्पन्न करने के लिए इस कोड का उपयोग न करें।


 int n = new Random().Next();

आप Next() फ़ंक्शन को न्यूनतम और अधिकतम मान भी दे सकते हैं। पसंद

 int n = new Random().Next(5,10);

Random r = new Random();
int n = r.Next();

यादृच्छिक संख्या बनाने के लिए इन सरल चरणों का प्रयास करें:

समारोह बनाएं

private int randomnumber(int min, int max)
{
    Random rnum = new Random();
    return rnum.Next(min, max);
}

उपरोक्त फ़ंक्शन का उपयोग उस स्थान पर करें जहां आप यादृच्छिक संख्याओं का उपयोग करना चाहते हैं। मान लीजिए कि आप इसे एक टेक्स्ट बॉक्स में उपयोग करना चाहते हैं।

textBox1.Text = randomnumber(0, 999).ToString();

0 मिनट और 99 9 अधिकतम है। आप जो भी चाहें मूल्यों को बदल सकते हैं।

इस पृष्ठ पर भी उत्तर की जांच करें।

( http://solutions.musanitech.com/c-how-to-create-random-numbers/ )


मैं एक यादृच्छिक संख्या के लिए नीचे कोड का उपयोग करें:

var random = new Random((int)DateTime.Now.Ticks);
var randomValue = random.Next(startValue, endValue + 1);

Random randomNumberGenerator = new Random ();
int randomNumber = randomNumberGenerator.Next (lowerBound,upperBound);

आप नीचे उपयोग करके यादृच्छिक बीज मूल्य के साथ प्रयास कर सकते हैं:

var rnd = new Random(11111111); //note: seed value is 11111111

string randomDigits = rnd.Next().ToString().Substring(0, 8);

var requestNumber = $"SD-{randomDigits}";

सवाल बहुत आसान लग रहा है लेकिन जवाब थोड़ा जटिल है। यदि आप देखते हैं कि लगभग हर किसी ने यादृच्छिक वर्ग का उपयोग करने का सुझाव दिया है और कुछ ने आरएनजी क्रिप्टो वर्ग का उपयोग करने का सुझाव दिया है। लेकिन फिर कब चुनना है।

इसके लिए हमें पहले रैंडमनेस और इसके पीछे के दर्शन को समझने की आवश्यकता है।

मैं आपको इस वीडियो को देखने के लिए प्रोत्साहित करता हूं जो सी # https://www.youtube.com/watch?v=tCYxc-2-3fY का उपयोग करके रैंडमनेस के दर्शन में गहराई से जाता है

सबसे पहले हमें रैंडमनेस के दर्शन को समझने दें। जब हम लाल, हरे और पीले के बीच चयन करने के लिए किसी व्यक्ति को आंतरिक रूप से क्या होता है। क्या व्यक्ति लाल या पीला या ग्रीन चुनता है?

कुछ शुरुआती विचार व्यक्तियों के दिमाग में जाते हैं जो उनकी पसंद का फैसला करते हैं, यह पसंदीदा रंग, भाग्यशाली रंग और अन्य हो सकता है। दूसरे शब्दों में कुछ प्रारंभिक ट्रिगर जिसे हम रेडॉम में सीड के रूप में देखते हैं। यह सीड शुरुआती बिंदु है, ट्रिगर जो उसे रैंडम वैल्यू का चयन करने के लिए प्रेरित करता है।

अब यदि एक सीईडी अनुमान लगाना आसान है तो उन प्रकार की यादृच्छिक संख्याओं को पीएसयूयूडीओ कहा जाता है और जब बीज को उन यादृच्छिक संख्याओं को अनुमान लगाने में मुश्किल होती है तो उन्हें सुरक्षित यादृच्छिक संख्या कहा जाता है।

उदाहरण के लिए एक व्यक्ति चुनता है मौसम और ध्वनि संयोजन के आधार पर रंग होता है तो शुरुआती बीज का अनुमान लगाना मुश्किल होगा।

अब मुझे एक महत्वपूर्ण बयान दें: -

* "यादृच्छिक" वर्ग केवल PSEUDO यादृच्छिक संख्या उत्पन्न करता है और सुरक्षित यादृच्छिक संख्या उत्पन्न करने के लिए हमें "RNGCryptoServiceProvider" कक्षा का उपयोग करने की आवश्यकता है।

यादृच्छिक वर्ग आपके सीपीयू घड़ी से बीज मूल्य लेता है जो बहुत अधिक अनुमानित है। तो दूसरे शब्दों में सी # के रैंडम वर्ग छद्म यादृच्छिक संख्या उत्पन्न करता है, नीचे के लिए कोड है।

Random rnd= new Random();
int rndnumber = rnd.Next()

जबकि RNGCryptoServiceProvider क्लास बीज उत्पन्न करने के लिए ओएस एन्ट्रॉपी का उपयोग करता है। ओएस एन्ट्रॉपी एक यादृच्छिक मान है जो ध्वनि, माउस क्लिक और कीबोर्ड समय, थर्मल टेम्प आदि का उपयोग करके उत्पन्न होता है। नीचे कोड इसके लिए जाता है।

using (RNGCryptoServiceProvider rg = new RNGCryptoServiceProvider()) 
{ 
  byte[] rno = new byte[5];    
  rg.GetBytes(rno);    
  int randomvalue = BitConverter.ToInt32(rno, 0); 
}

ओएस एन्ट्रॉपी को समझने के लिए 11:20 से इस वीडियो को https://www.youtube.com/watch?v=tCYxc-2-3fY देखें जहां ओएस एन्ट्रॉपी का तर्क समझाया गया है। तो सरल शब्दों में डालकर आरएनजी क्रिप्टो सुरक्षित यादृच्छिक संख्या उत्पन्न करता है।


वास्तविक यादृच्छिक संख्या सुनिश्चित करने के लिए, मौजूदा मिलीसेकंड के साथ रैंडम ऑब्जेक्ट को बीज करना बेहतर है, और आपको इसे कई बार डुप्लीकेट नहीं मिलेंगे

Random rand = new Random(DateTime.Now.Millisecond);

मैंने COBOL उत्तर को छोड़कर इन सभी समाधानों का प्रयास किया है ... lol

इनमें से कोई भी समाधान पर्याप्त नहीं था। मुझे इंट लूप के लिए तेजी से रैंडम्स की आवश्यकता थी और मुझे बहुत विस्तृत श्रेणियों में भी डुप्लिकेट मान मिल रहे थे। यादृच्छिक परिणामों के लिए बहुत लंबे समय तक निपटने के बाद मैंने अंततः एक बार और सभी के लिए इस समस्या से निपटने का फैसला किया।

यह सब बीज के बारे में है।

मैं ग्रिड से गैर अंकों को पार्स करके एक यादृच्छिक पूर्णांक बनाता हूं, फिर मैं अपने रैंडम क्लास को तुरंत चालू करने के लिए इसका उपयोग करता हूं।

public int GenerateRandom(int min, int max)
{
    var seed = Convert.ToInt32(Regex.Match(Guid.NewGuid().ToString(), @"\d+").Value);
    return new Random(seed).Next(min, max);
}

अद्यतन : यदि आप एक बार यादृच्छिक वर्ग को तुरंत चालू करते हैं तो सीडिंग आवश्यक नहीं है। तो यह एक स्थिर वर्ग बनाने और उस से एक विधि को कॉल करने के लिए सबसे अच्छा होगा।

public static class IntUtil
{
   private static Random random;

   private static void Init()
   {
      if (random == null) random = new Random();
   }

   public static int Random(int min, int max)
   {
      Init();
      return random.Next(min, max);
   }
}

फिर आप इस तरह के स्थिर वर्ग का उपयोग कर सकते हैं ..

for(var i = 0; i < 1000; i++)
{
   int randomNumber = IntUtil.Random(1,100);
   Console.WriteLine(randomNumber); 
}

मैं मानता हूं कि मुझे इस दृष्टिकोण को बेहतर पसंद है।


Random क्लास यादृच्छिक संख्या बनाने के लिए प्रयोग किया जाता है। (छद्म-यादृच्छिक जो निश्चित रूप से है।)।

उदाहरण:

Random rnd = new Random();
int month = rnd.Next(1, 13); // creates a number between 1 and 12
int dice = rnd.Next(1, 7);   // creates a number between 1 and 6
int card = rnd.Next(52);     // creates a number between 0 and 51

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


int randomNumber = Random.Range(start_range, end_range) उपयोग क्यों न करें?


एक निर्धारिती प्रक्रिया के माध्यम से कंप्यूटर द्वारा गणना की गई संख्या, परिभाषा के अनुसार, यादृच्छिक नहीं हो सकती है।

यदि आप एक वास्तविक यादृच्छिक संख्या चाहते हैं, तो यादृच्छिकता वायुमंडलीय शोर या रेडियोधर्मी क्षय से आता है।

उदाहरण के लिए आप RANDOM.ORG (यह प्रदर्शन को कम कर सकता है)


मैं यह दिखाना चाहता था कि क्या होता है जब हर बार एक नया यादृच्छिक जनरेटर उपयोग किया जाता है। मान लें कि आपके पास दो विधियां या दो कक्षाएं हैं जिनमें प्रत्येक को यादृच्छिक संख्या की आवश्यकता होती है। और मूर्खतापूर्ण आप उन्हें कोड करते हैं:

public class A
{
    public A()
    {
        var rnd=new Random();
        ID=rnd.Next();
    }
    public int ID { get; private set; }
}
public class B
{
    public B()
    {
        var rnd=new Random();
        ID=rnd.Next();
    }
    public int ID { get; private set; }
}

क्या आपको लगता है कि आपको दो अलग-अलग आईडी मिलेंगी? नहींं

class Program
{
    static void Main(string[] args)
    {
        A a=new A();
        B b=new B();

        int ida=a.ID, idb=b.ID;
        // ida = 1452879101
        // idb = 1452879101
    }
}

समाधान हमेशा एक स्थिर यादृच्छिक जनरेटर का उपयोग करना है। इस कदर:

public static class Utils
{
    public static readonly Random random=new Random();
}

public class A
{
    public A()
    {
        ID=Utils.random.Next();
    }
    public int ID { get; private set; }
}
public class B
{
    public B()
    {
        ID=Utils.random.Next();
    }
    public int ID { get; private set; }
}




random