मैं दो अलग-अलग श्रेणियों से एक यादृच्छिक संख्या कैसे उत्पन्न कर सकता हूं?

उदाहरण के लिए: 10-20 और 50-60 से एक नंबर।

मुझे पता है कि एक श्रेणी (1-13) से एक यादृच्छिक संख्या कैसे उत्पन्न की जाती है:

Random rnd = new Random();
int num = rnd.Next(1, 13);
4
avi sikirov 13 नवम्बर 2015, 00:08

5 जवाब

सबसे बढ़िया उत्तर
int num = rnd.Next(1, 3)==1 ? rnd.Next(10, 21) : rnd.Next(50,61);

या

int num = rnd.Next(10, 32);
if (num>20) num+=29;

या सिर्फ मनोरंजन के लिए (बड़ी रेंज के साथ उपयोग न करें, और किसी भी तरह धीमी गति से चलता है):

var ranges=new []{ Tuple.Create(10,20), Tuple.Create(50,60)};
var rnd=new Random();
var possible=ranges.Select(x=>Enumerable.Range(x.Item1,x.Item2-x.Item1+1))
  .SelectMany(x=>x)
  .Distinct();
var num=possible.Skip(rnd.Next(0,possible.Count())).First();
6
Robert McKee 12 नवम्बर 2015, 22:16

अगली विधि के लिए याद रखें, निचला बाउंड समावेशी है, जबकि ऊपरी बाउंड अनन्य है। कैसा रहेगा:

var rand = new Random();
var num1 = rand.Next(10, 21);

var num2 = rand.Next(50, 61);

var myNum = rand.Next(0, 2) == 1 ? num1 : num2;
2
Sean 12 नवम्बर 2015, 21:14

आप 22 विशिष्ट यादृच्छिक संख्याएं, 10-20 और 50-60 उत्पन्न कर रहे हैं। तो पहले ऐसा करें:

int randomNumber = rnd.Next(0, 22);

अब, आपके पास 0 से 21 तक यादृच्छिक संख्या है।

दस जोड़ें:

randomNumber += 10;

अब, आपके पास 10 से 31 के बीच यादृच्छिक संख्याएँ हैं।

सभी संख्याओं के लिए 29 जोड़ें> = 21:

if (randomNumber >= 21) {
    randomNumber += 29;
}

अब, आपके पास 10 से 20 तक और 50 से 60 तक यादृच्छिक संख्याएँ हैं।

2
Jan Doerrenhaus 12 नवम्बर 2015, 21:17

एक अधिक सामान्य दृष्टिकोण एक एक्सटेंशन विधि जिसमें आप NextFromRanges और NextDoubleFromRanges तरीके जोड़ते हैं। तो यह किसी भी प्रकार की किसी भी श्रेणी के लिए काम करेगा।
सबसे पहले आपको Range वर्ग को परिभाषित करना होगा। इसे जेनेरिक बना दें ताकि आप इसका पुनः उपयोग कर सकें न केवल int पर्वतमाला बल्कि double के लिए विभिन्न प्रकार, उदाहरण के लिए।

/// <summary>The Range class.</summary>
/// <typeparam name="T">Generic parameter.</typeparam>
public class Range<T>
{
    /// <summary>Minimum value of the range.</summary>
    public T Minimum { get; set; }

    /// <summary>Maximum value of the range.</summary>
    public T Maximum { get; set; }

    public Range(T min, T max)
    {
        Minimum = min;
        Maximum = max;
    }
}

public static class RandomExtension
{
    static Random random = new Random();

    public static int NextFromRanges(this Random random, List<Range<int>> ranges)
    {
        int randomRange = random.Next(0, ranges.Count);
        return random.Next(ranges[randomRange].Minimum, ranges[randomRange].Maximum);
    }

    public static double NextDoubleFromRanges(this Random random, List<Range<double>> ranges)
    {
        int randomRange = random.Next(0, ranges.Count);
        double doubleNrRange = ranges[randomRange].Maximum - ranges[randomRange].Minimum;
        return ranges[randomRange].Minimum + random.NextDouble()*doubleNrRange;
    }
}

और फिर आप इसे इस तरह से उपयोग कर सकते हैं:

    //instantiate a Random generator
    Random random = new Random();

    //define three integer ranges
    List<Range<int>> intRanges = new List<Range<int>>();
    intRanges.Add(new Range<int>(0, 10));
    intRanges.Add(new Range<int>(50, 60));
    intRanges.Add(new Range<int>(100, 110));

    //define three double ranges
    List<Range<double>> doubleRanges = new List<Range<double>>();
    doubleRanges.Add(new Range<double>(0, 5.5));
    doubleRanges.Add(new Range<double>(50, 55.5));
    doubleRanges.Add(new Range<double>(100, 105.5));

    //generate a random number between one of above three ranges
    //it is shown in the Visual Studio - Output window (Ctrl-W,O)
    Console.WriteLine(random.NextFromRanges(intRanges));
    Console.WriteLine(random.NextDoubleFromRanges(doubleRanges));

यह उत्पादन करेगा:
दिए गए तीन int रेंज में से एक के बीच संख्या int नंबर: 0-10, 50-60 और 100-110।
दिए गए तीन double श्रेणियों में से एक के बीच संख्या double नंबर: 0-5.5, 50-55.5, 100-105.5

जैसे आगे और विधियाँ ऊपरी भाग अनन्य है

अब आपके पास मानक में दो अतिरिक्त विधियाँ जोड़ी जाएँगी रैंडम वर्ग: यहां छवि विवरण दर्ज करें

2
Jan 28 फरवरी 2019, 20:29

आप अपनी खुद की रैंडम क्लास लिख सकते हैं। जहाँ आप एक नए अधिभार के साथ अगली विधि को फिर से लिखते हैं जो तर्कों की एक समान संख्या को स्वीकार करेगा।

यह कुछ इस तरह दिखेगा:

Random.NextFromGroups(10, 20, 50, 60, 100, 110);

जहाँ संख्या-युग्म का अर्थ पर्वतमाला है।

हस्ताक्षर:

int NextFromGroups(params int[]);

और जब यह एक विषम संख्या में तर्क प्राप्त करता है तो यह एक अपवाद को फेंक देगा।

-2
Mitulát báti 12 नवम्बर 2015, 21:47