شرح توليد أرقام كاملة عشوائية في JavaScript في نطاق معين؟




شرح جافا سكريبت (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;

https://code.i-harness.com

كيف يمكنني إنشاء رقم صحيح عشوائي بين متغيرين محددين في Javascript ، على سبيل المثال x = 4 و y = 8 سيخرج أيًا من 4 و 5 و 6 و 7 و 8؟


أعلم أن هذا السؤال تمت الإجابة عليه بالفعل ولكن إجابتي يمكن أن تساعد شخصًا ما.

لقد وجدت هذه الطريقة البسيطة في W3Schools:

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

آمل أن هذا من شأنه أن يساعد شخص ما.


إرجاع رقم عشوائي بين 1 و 10:

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

إرجاع رقم عشوائي بين 1 و 100:

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

إليك ما أستخدمه لإنشاء أرقام عشوائية.

function random(high,low) {
    high++;
    return Math.floor((Math.random())*(high-low))+low;
}

نحن ننفذ high++ لأن Math.random() يولد رقمًا عشوائيًا بين 0 ، (شامل) ، و 1 (حصري) أما الذي يتم استبعاده ، فيعني أنه يجب علينا أن نزيد ارتفاعًا واحدًا قبل تنفيذ أي رياضيات. ثم نطرح منخفضًا من الأعلى ، مما يمنحنا أعلى رقم لتوليده - منخفضًا ، ثم إلى + منخفض ، مما يجعله مرتفعًا إلى وضعها الطبيعي ، وجعل أقل عدد على الأقل منخفضًا. ثم نعيد الرقم الناتج

random(7,3) يمكن أن ترجع 3,4,5,6, or 7


باستخدام التعليمة البرمجية التالية ، يمكنك إنشاء مجموعة من الأرقام العشوائية ، دون تكرار ، في نطاق معين.

function genRandomNumber(how_many_number,min,max) {

            // parameters
            // how_many_number : how many numbers you want to generate. For example it is 5.
            // min(inclusive) : minimum/low value of a range. it must be any positive integer but less than max. i.e 4
            // max(inclusive) : maximun value of a range. it must be any positive integer. i.e 50
            // return type: array

            var random_number = [];
            for (var i = 0; i < how_many_number; i++) {
                var gen_num = parseInt((Math.random() * (max-min+1)) + min);
                do {
                    var is_exist = random_number.indexOf(gen_num);
                    if (is_exist >= 0) {
                        gen_num = parseInt((Math.random() * (max-min+1)) + min);
                    }
                    else {
                        random_number.push(gen_num);
                        is_exist = -2;
                    }
                }
                while (is_exist > -1);
            }
            document.getElementById('box').innerHTML = random_number;
        }

بعد إنشاء رقم عشوائي باستخدام برنامج كمبيوتر ، ما زال يعتبر رقمًا عشوائيًا إذا كان الرقم الذي تم اختياره جزءًا أو جزءًا كاملاً من الرقم الأولي. ولكن إذا تم تغييرها ، فإن علماء الرياضيات لا يقبلونها كعدد عشوائي ويمكنهم أن يطلقوا عليها رقمًا متحيزًا. ولكن إذا كنت تقوم بتطوير برنامج لمهمة بسيطة ، فلن يكون هذا هو الحال للنظر فيه. ولكن إذا كنت تقوم بتطوير برنامج لتوليد رقم عشوائي لأشياء ثمينة مثل برنامج اليانصيب ، أو لعبة القمار ، فسيتم رفض برنامجك من قبل الإدارة إذا لم تكن تفكر في الحالة المذكورة أعلاه.

لذلك بالنسبة إلى هذا النوع من الأشخاص ، إليك اقتراحي:

إنشاء رقم عشوائي باستخدام Math.random() . (قل هذا n )

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] ، فإن الكلمة من n * 10 هي إجابتك وإذا كنت بحاجة إلى [0،99] ، فإن الكلمة من n * 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 في Chrome لفتح وحدة التحكم)


في ما يلي تطبيق MS DotNet للفئة العشوائية في جافا سكريبت

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

للحصول على رقم عشوائي يقول ما بين 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 من الحد الأدنى للقيمة ، فإنك تمنع القيمة القصوى من التقريب.

امل ان يساعد.


مهلا يا رفاق لقد قمت بإنشاء وظيفة javascript نفس 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;
    }

هذا هو بلدي على عدد عشوائي في مجموعة ، كما هو الحال في أردت الحصول على رقم عشوائي ضمن مجموعة من الأساس إلى الأس. على سبيل المثال قاعدة = 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);

هناك بعض الأمثلة على صفحة شبكة مطوري برامج Mozilla :

/**
 * 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() Number بين 0 (ضمناً) و 1 (خاص). لذلك لدينا فاصل كهذا:

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

الآن ، نرغب في الحصول على رقم بين الحد min (شامل) والحد max (حصري):

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

يمكننا استخدام Math.random للحصول على المراسل في الفاصل الزمني [min، max). ولكن ، أولاً يجب أن نعالج المشكلة عن طريق طرح الحد 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 إلى الخلف ، حتى نحصل على رقم في الفاصل الزمني [min، max):

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

كانت هذه أول وظيفة من MDN. أما الثانية ، فتُرجع عددًا صحيحًا بين max min max ، كليهما.

الآن للحصول على الأعداد الصحيحة ، يمكنك استخدام round أو ceil أو floor .

يمكنك استخدام Math.round(Math.random() * (max - min)) + min ، ومع ذلك يوفر توزيعًا غير متساوي. على حد سواء ، max 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 لديك توزيع متساو تمامًا.

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 والعلوية والشاملة. نحن نقول "شامل" لأننا نريد تضمين كلا من القاع والعلامة في نطاق الأرقام التي يمكن إرجاعها. بهذه الطريقة ، سيعود getRandomizer( 1, 6 ) إما 1 ، 2 ، 3 ، 4 ، 5 ، أو 6.

(السفلي هو رقم أقل ، أعلى رقم أكبر)

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

Math.random() بإرجاع مزدوج عشوائي بين 0 و 1 ، وإذا ضربناه بواحد زائد الفرق بين top bottom ، فسوف نحصل على مضاعفة في مكان ما بين 0 و 1+ba .

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

تقريب Math.floor العدد لأسفل إلى أقرب عدد صحيح. لذلك لدينا الآن كل الأعداد الصحيحة بين 0 top-bottom . يبدو 1 مربكًا ، ولكن يجب أن يكون هناك لأننا دائمًا ما يتم التقريب ، لذا لن يتم الوصول إلى الرقم الأعلى بدونه. يجب أن تكون القيمة العشرية العشوائية التي ننتجها في النطاق من 0 إلى (1+top-bottom) حتى يمكننا تدويرها والحصول على int في النطاق من 0 إلى top-bottom

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

أعطتنا الشفرة في المثال السابق عددًا صحيحًا من النطاق 0 ومن top-bottom ، لذلك كل ما نحتاج إلى القيام به الآن هو إضافة bottom إلى تلك النتيجة للحصول على عدد صحيح في bottom النطاق وأشمل. :د

ملاحظة: إذا قمت بتمرير قيمة غير صحيحة أو العدد الأكبر أولاً ستحصل على سلوك غير مرغوب فيه ، ولكن ما لم يطلبه أحد ، فلن أتطرق إلى الحجة التي تفحص الشفرة باعتبارها بعيدة عن القصد من السؤال الأصلي .


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

بديل إذا كنت تستخدم Underscore.js يمكنك استخدامها

_.random(min, max)






integer