javascript - style - स्क्रिप्टिंग भाषा




एक विशिष्ट सीमा में जावास्क्रिप्ट में यादृच्छिक पूर्ण संख्या उत्पन्न करना? (14)

Math.random()

Math.random() डेवलपर नेटवर्क दस्तावेज़ से:

// Returns a random integer between min and max

function getRandomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

उपयोगी उदाहरण:

// 0 - 10
Math.floor(Math.random() * 11);

// 1 - 10
Math.floor(Math.random() * 10) + 1;

// 5 - 20
Math.floor(Math.random() * 16) + 5;

// -10 - (-2)
Math.floor(Math.random() * 9) - 10;

मैं जावास्क्रिप्ट में दो निर्दिष्ट चर के बीच एक यादृच्छिक पूर्ण संख्या कैसे उत्पन्न कर सकता हूं, उदाहरण के लिए x = 4 और y = 8 4, 5, 6, 7, 8 में से किसी एक को आउटपुट करेगा?


1 और 10 के बीच एक यादृच्छिक संख्या लौटें:

Math.floor((Math.random()*10) + 1); 

1 और 100 के बीच एक यादृच्छिक संख्या लौटें:

Math.floor((Math.random()*100) + 1)

अरे दोस्तों मैंने एक जावास्क्रिप्ट फ़ंक्शन बनाया है जैसे Math.random () जिसका उपयोग हम किसी निर्दिष्ट लंबाई की यादृच्छिक संख्या उत्पन्न कर सकते हैं। किसी भी Math.random फ़ंक्शन का उपयोग किए बिना।

    function genRandom(length)
    {
     const t1 = new Date().getMilliseconds();
     var min = "1",max = "9";
     var result;
     var numLength = length;
     if (numLength != 0)
     {
        for (var i = 1; i < numLength; i++)
        {
           min = min.toString() + "0";
           max = max.toString() + "9";
        }
     } 
     else
     {
        min = 0;
        max = 0;
        return; 
     }

      for (var i = min; i <= max; i++)
      {
           //Empty Loop
      }

      const t2 = new Date().getMilliseconds();
      console.log(t2);
      result = ((max - min)*t1)/t2;
      console.log(result);
      return result;
    }

एक यादृच्छिक संख्या प्राप्त करने के लिए 1 और 6 के बीच कहें, पहले करें:

    0.5 + (Math.random() * ((6 - 1) + 1))

यह एक यादृच्छिक संख्या 6 से गुणा करता है और उसके बाद 0.5 जोड़ता है। ऐसा करके एक सकारात्मक पूर्णांक की संख्या के आगे:

    Math.round(0.5 + (Math.random() * ((6 - 1) + 1))

यह संख्या निकटतम पूर्ण संख्या तक है।

या इसे और अधिक समझने योग्य बनाने के लिए यह करें:

    var value = 0.5 + (Math.random() * ((6 - 1) + 1))
    var roll = Math.round(value);
    return roll;

सामान्य रूप से चर का उपयोग कर ऐसा करने के लिए कोड है:

    var value = (Min - 0.5) + (Math.random() * ((Max - Min) + 1))
    var roll = Math.round(value);
    return roll;

न्यूनतम मूल्य से 0.5 दूर करने का कारण यह है कि अकेले न्यूनतम मूल्य का उपयोग करने से आप एक पूर्णांक प्राप्त कर सकते हैं जो आपके अधिकतम मूल्य से अधिक था। न्यूनतम मूल्य से 0.5 को दूर करके आप अनिवार्य रूप से अधिकतम मूल्य को गोलाकार होने से रोक रहे हैं।

उम्मीद है की वो मदद करदे।


कंप्यूटर प्रोग्राम का उपयोग करके यादृच्छिक संख्या उत्पन्न करने के बाद, यह अभी भी यादृच्छिक संख्या के रूप में माना जाता है यदि उठाया गया नंबर एक भाग है या प्रारंभिक में से एक पूर्ण है। लेकिन अगर यह बदला गया, तो गणितज्ञ इसे यादृच्छिक संख्या के रूप में स्वीकार नहीं करते हैं और वे इसे पक्षपातपूर्ण संख्या कह सकते हैं। लेकिन यदि आप एक साधारण कार्य के लिए एक कार्यक्रम विकसित कर रहे हैं, तो यह विचार करने का मामला नहीं होगा। लेकिन यदि आप लॉटरी प्रोग्राम, या जुआ गेम जैसे मूल्यवान सामान के लिए यादृच्छिक संख्या उत्पन्न करने के लिए एक प्रोग्राम विकसित कर रहे हैं, तो यदि आप उपर्युक्त मामले पर विचार नहीं करते हैं तो आपका प्रोग्राम प्रबंधन द्वारा खारिज कर दिया जाएगा।

तो उन लोगों के लिए, मेरा सुझाव यहां है:

Math.random() का उपयोग करके एक यादृच्छिक संख्या उत्पन्न करें। (यह कहें)

Now for [0,10) ==>  n*10 (i.e. one digit) and for[10,100) ==> n*100 (i.e. two digits) and so on. Here squire bracket indicates that boundary is inclusive and round bracket indicates boundary is exclusive.
Then remove the rest after the decimal point. (i.e. get floor) - using Math.floor(), this can be done.

यदि आप यादृच्छिक संख्या चुनने के लिए यादृच्छिक संख्या तालिका को कैसे पढ़ना चाहते हैं, तो आप उपर्युक्त प्रक्रिया (1, 10, 100 से गुणा करके) को जानते हैं) जिसकी शुरुआत में मैंने उल्लेख किया था उसका उल्लंघन नहीं करता है। (क्योंकि यह केवल तभी बदलता है दशमलव बिंदु की जगह।)

निम्नलिखित उदाहरण का अध्ययन करें और इसे अपनी आवश्यकताओं के अनुसार विकसित करें।

यदि आपको नमूना की आवश्यकता है [0,9] तो एन * 10 का फर्श आपका उत्तर है और यदि [0,99] की आवश्यकता है तो एन * 100 का फर्श आपका जवाब है और इसी तरह।

अब अपनी भूमिका में प्रवेश करें:

आपने विशिष्ट सीमा के बीच संख्याएं पूछे हैं। (इस मामले में आप उस सीमा के बीच पक्षपातपूर्ण हैं। - एक मरने के द्वारा [1,6] से एक संख्या ले कर, तो आप [1,6] में पक्षपाती हैं लेकिन फिर भी यह एक यादृच्छिक है और केवल अगर मरना निष्पक्ष है ।)

तो अपनी सीमा ==> [78, 247] श्रेणी = 247 - 78 + 1 = 170 के तत्वों की संख्या पर विचार करें; (क्योंकि दोनों सीमाएं समावेशी हैं।

/*Mthod 1:*/
    var i = 78, j = 247, k = 170, a = [], b = [], c, d, e, f, l = 0;
    for(; i <= j; i++){ a.push(i); }
    while(l < 170){
        c = Math.random()*100; c = Math.floor(c);
        d = Math.random()*100; d = Math.floor(d);
        b.push(a[c]); e = c + d;
        if((b.length != k) && (e < k)){  b.push(a[e]); }
        l = b.length;
    }
    console.log('Method 1:');
    console.log(b);
/*Method 2:*/

    var a, b, c, d = [], l = 0;
    while(l < 170){
        a = Math.random()*100; a = Math.floor(a);
        b = Math.random()*100; b = Math.floor(b);
        c = a + b;
        if(c <= 247 || c >= 78){ d.push(c); }else{ d.push(a); }
        l = d.length;
    }
    console.log('Method 2:');
    console.log(d);

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

दोनों तरीकों से, आपका कंसोल परिणाम दिखाएगा। (कंसोल खोलने के लिए क्रोम में f12 दबाएं)


निम्नतम और उच्चतम के बीच यादृच्छिक पूर्ण संख्या:

function randomRange(l,h){
  var range = (h-l);
  var random = Math.floor(Math.random()*range);
  if (random === 0){random+=1;}
  return l+random;
}

सबसे सुरुचिपूर्ण समाधान नहीं .. लेकिन कुछ जल्दी।


मुझे पता है कि यह सवाल पहले से ही उत्तर दिया गया है लेकिन मेरा जवाब किसी की मदद कर सकता है।

मुझे डब्ल्यू 3 स्कूल्स पर यह सरल विधि मिली:

Math.floor((Math.random() * max) + min);

उम्मीद है कि यह किसी की मदद करेगा।


यदि आपको परिवर्तनीय betwee 0 और अधिकतम की आवश्यकता है तो आप इसका उपयोग कर सकते हैं:

Math.floor(Math.random() *  max);

यह एक रेंज में एक यादृच्छिक संख्या पर मेरा लेना है, क्योंकि मैं आधार पर एक सीमा के भीतर एक यादृच्छिक संख्या प्राप्त करना चाहता था। उदाहरण के लिए बेस = 10, एक्सपोनेंट = 2, एक यादृच्छिक संख्या 0 से 100, आदर्श, और इसी तरह से देता है।

अगर यह इसका उपयोग करने में मदद करता है, तो यह है:

// get random number within provided base + exponent
// by Goran Biljetina --> 2012

function isEmpty(value){
    return (typeof value === "undefined" || value === null);
}
var numSeq = new Array();
function add(num,seq){
    var toAdd = new Object();
     toAdd.num = num;
     toAdd.seq = seq;
     numSeq[numSeq.length] = toAdd;
}
function fillNumSeq (num,seq){
    var n;
    for(i=0;i<=seq;i++){
        n = Math.pow(num,i);
        add(n,i);
    }
}
function getRandNum(base,exp){
    if (isEmpty(base)){
        console.log("Specify value for base parameter");
    }
    if (isEmpty(exp)){
        console.log("Specify value for exponent parameter");
    }
    fillNumSeq(base,exp);
    var emax;
    var eseq;
    var nseed;
    var nspan;
    emax = (numSeq.length);
    eseq = Math.floor(Math.random()*emax)+1;
    nseed = numSeq[eseq].num;
    nspan = Math.floor((Math.random())*(Math.random()*nseed))+1;
    return Math.floor(Math.random()*nspan)+1;
}

console.log(getRandNum(10,20),numSeq);
//testing:
//getRandNum(-10,20);
//console.log(getRandNum(-10,20),numSeq);
//console.log(numSeq);

यहां जावास्क्रिप्ट में यादृच्छिक वर्ग के एमएस डॉटनेट कार्यान्वयन है-

var Random = (function () {
function Random(Seed) {
    if (!Seed) {
        Seed = this.milliseconds();
    }
    this.SeedArray = [];
    for (var i = 0; i < 56; i++)
        this.SeedArray.push(0);
    var num = (Seed == -2147483648) ? 2147483647 : Math.abs(Seed);
    var num2 = 161803398 - num;
    this.SeedArray[55] = num2;
    var num3 = 1;
    for (var i_1 = 1; i_1 < 55; i_1++) {
        var num4 = 21 * i_1 % 55;
        this.SeedArray[num4] = num3;
        num3 = num2 - num3;
        if (num3 < 0) {
            num3 += 2147483647;
        }
        num2 = this.SeedArray[num4];
    }
    for (var j = 1; j < 5; j++) {
        for (var k = 1; k < 56; k++) {
            this.SeedArray[k] -= this.SeedArray[1 + (k + 30) % 55];
            if (this.SeedArray[k] < 0) {
                this.SeedArray[k] += 2147483647;
            }
        }
    }
    this.inext = 0;
    this.inextp = 21;
    Seed = 1;
}
Random.prototype.milliseconds = function () {
    var str = new Date().valueOf().toString();
    return parseInt(str.substr(str.length - 6));
};
Random.prototype.InternalSample = function () {
    var num = this.inext;
    var num2 = this.inextp;
    if (++num >= 56) {
        num = 1;
    }
    if (++num2 >= 56) {
        num2 = 1;
    }
    var num3 = this.SeedArray[num] - this.SeedArray[num2];
    if (num3 == 2147483647) {
        num3--;
    }
    if (num3 < 0) {
        num3 += 2147483647;
    }
    this.SeedArray[num] = num3;
    this.inext = num;
    this.inextp = num2;
    return num3;
};
Random.prototype.Sample = function () {
    return this.InternalSample() * 4.6566128752457969E-10;
};
Random.prototype.GetSampleForLargeRange = function () {
    var num = this.InternalSample();
    var flag = this.InternalSample() % 2 == 0;
    if (flag) {
        num = -num;
    }
    var num2 = num;
    num2 += 2147483646.0;
    return num2 / 4294967293.0;
};
Random.prototype.Next = function (minValue, maxValue) {
    if (!minValue && !maxValue)
        return this.InternalSample();
    var num = maxValue - minValue;
    if (num <= 2147483647) {
        return parseInt((this.Sample() * num + minValue).toFixed(0));
    }
    return this.GetSampleForLargeRange() * num + minValue;
};
Random.prototype.NextDouble = function () {
    return this.Sample();
};
Random.prototype.NextBytes = function (buffer) {
    for (var i = 0; i < buffer.length; i++) {
        buffer[i] = this.InternalSample() % 256;
    }
};
return Random;
}());

उपयोग:

        var r = new Random();
        var nextInt = r.Next(1, 100); //returns an integer between range
        var nextDbl = r.NextDouble(); //returns a random decimal

मोज़िला डेवलपर नेटवर्क पेज पर कुछ उदाहरण हैं:

/**
 * Returns a random number between min (inclusive) and max (exclusive)
 */
function getRandomArbitrary(min, max) {
    return Math.random() * (max - min) + min;
}

/**
 * Returns a random integer between min (inclusive) and max (inclusive)
 * Using Math.round() will give you a non-uniform distribution!
 */
function getRandomInt(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
}

इसके पीछे तर्क है। यह तीन का एक साधारण नियम है:

Math.random() 0 (समावेशी) और 1 (अनन्य) के बीच एक Number देता है। तो हमारे पास इस तरह का अंतराल है:

[0 .................................... 1)

अब, हम min (समावेशी) और max (अनन्य) के बीच एक संख्या चाहते हैं:

[0 .................................... 1)
[min .................................. max)

हम [मिनट, अधिकतम) अंतराल में संवाददाता प्राप्त करने के लिए Math.random का उपयोग कर सकते हैं। लेकिन, पहले हमें दूसरे अंतराल से min घटाकर समस्या को थोड़ा सा कारक बनाना चाहिए:

[0 .................................... 1)
[min - min ............................ max - min)

यह देता है:

[0 .................................... 1)
[0 .................................... max - min)

अब हम Math.random लागू कर सकते हैं और फिर संवाददाता की गणना कर सकते हैं। आइए एक यादृच्छिक संख्या चुनें:

                Math.random()
                    |
[0 .................................... 1)
[0 .................................... max - min)
                    |
                    x (what we need)

तो, x खोजने के लिए, हम करेंगे:

x = Math.random() * (max - min);

min वापस जोड़ने के लिए मत भूलना, ताकि हम [न्यूनतम, अधिकतम) अंतराल में एक संख्या प्राप्त कर सकें:

x = Math.random() * (max - min) + min;

एमडीएन से यह पहला कार्य था। दूसरा, दोनों समावेशी सहित min और max बीच एक पूर्णांक देता है।

अब पूर्णांक प्राप्त करने के लिए, आप round , floor या floor उपयोग कर सकते हैं।

आप Math.round(Math.random() * (max - min)) + min उपयोग कर सकते हैं, हालांकि यह एक गैर-वितरण भी प्रदान करता है। दोनों, min और max केवल रोल करने का लगभग आधा मौका है:

min...min+0.5...min+1...min+1.5   ...    max-0.5....max
└───┬───┘└────────┬───────┘└───── ... ─────┘└───┬──┘   ← Math.round()
   min          min+1                          max

अंतराल से max छोड़कर, इसमें min से रोल करने का एक कम मौका होता है।

Math.floor(Math.random() * (max - min +1)) + min साथ Math.floor(Math.random() * (max - min +1)) + min आपके पास पूरी तरह से वितरण भी है।

min.... min+1... min+2 ... max-1... max.... max+1 (is excluded from interval)
|        |        |         |        |        |
└───┬───┘└───┬───┘└─── ... ┘└───┬───┘└───┬───┘   ← Math.floor()
   min     min+1               max-1    max

आप उस समीकरण में ceil() और -1 उपयोग नहीं कर सकते क्योंकि max अब रोल करने के लिए थोड़ा कम मौका था, लेकिन आप (अवांछित) min-1 परिणाम भी रोल कर सकते हैं।


    <!DOCTYPE html>
<html>
    <head>
            <meta charset="utf-8" />
    </head>
    <body>
        <script>
            /*

                assuming that window.crypto.getRandomValues is available
                the real range would be fron 0 to 1,998 instead of 0 to 2,000
                See javascript documentation for explanation
                https://developer.mozilla.org/en-US/docs/Web/API/RandomSource/getRandomValues
            */
            var array = new Uint8Array(2);
            window.crypto.getRandomValues(array);
            console.log(array[0] + array[1]);

        </script>
    </body>
</html>

Uint8Array 3 अंकों तक की संख्या से भरा एक सरणी बनाएं जो अधिकतम 999 होगा। यह कोड बहुत छोटा है।


function getRandomizer(bottom, top) {
    return function() {
        return Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom;
    }
}

उपयोग:

var rollDie = getRandomizer( 1, 6 );

var results = ""
for ( var i = 0; i<1000; i++ ) {
    results += rollDie() + " ";    //make a string filled with 1000 random numbers in the range 1-6.
}

टूट - फूट:

हम एक फ़ंक्शन लौटा रहे हैं (कार्यात्मक प्रोग्रामिंग से उधार लेना) जिसे कॉल किया जाता है, मूल्यों के bottom और top बीच एक यादृच्छिक पूर्णांक लौटाएगा। हम 'समावेशी' कहते हैं क्योंकि हम संख्याओं की संख्या में नीचे और ऊपर दोनों शामिल करना चाहते हैं जिन्हें वापस किया जा सकता है। इस तरह, getRandomizer( 1, 6 ) या तो 1, 2, 3, 4, 5, या 6 लौटाएगा।

(नीचे कम संख्या है, शीर्ष अधिक संख्या है)

Math.random() * ( 1 + top - bottom )

Math.random() 0 और 1 के बीच एक यादृच्छिक डबल देता है, और यदि हम इसे एक bottom गुणा करते हैं तो top और bottom बीच अंतर, हम 0 और 1+ba बीच कहीं भी दोगुना हो जाएंगे।

Math.floor( Math.random() * ( 1 + top - bottom ) )

Math.floor संख्या को निकटतम पूर्णांक तक गोल करता है। तो अब हमारे पास 0 और top-bottom बीच सभी पूर्णांक हैं। 1 उलझन में दिखता है, लेकिन इसे वहां होना जरूरी है क्योंकि हम हमेशा घूमते रहते हैं, इसलिए शीर्ष संख्या वास्तव में इसके बिना कभी नहीं पहुंच जाएगी। हमारे द्वारा जेनरेट किए गए यादृच्छिक दशमलव को 0 से (1+top-bottom) श्रेणी में होना आवश्यक है ताकि हम नीचे गोल कर सकें और 0 से top-bottom एक int प्राप्त कर सकें

Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom

पिछले उदाहरण में कोड ने हमें श्रेणी 0 और top-bottom में एक पूर्णांक दिया है, इसलिए अब हमें केवल इतना करना है कि उस परिणाम में bottom की सीमा और top समावेशी में पूर्णांक प्राप्त करने के लिए उस परिणाम को bottom जोड़ें। : डी

नोट: यदि आप एक गैर-पूर्णांक मान या अधिक संख्या में पहले पास करते हैं तो आपको अवांछनीय व्यवहार मिल जाएगा, लेकिन जब तक कि कोई भी अनुरोध नहीं करता है, मैं तर्क प्रश्न कोड में मूल प्रश्न के इरादे से दूर नहीं जा रहा हूं ।


function randomRange(min, max) {
  return ~~(Math.random() * (max - min + 1)) + min
}

वैकल्पिक यदि आप Underscore.js का उपयोग कर रहे हैं तो आप इसका उपयोग कर सकते हैं

_.random(min, max)





integer