මම කොහොමද උදා, ජාවාස්ක්රිප්ට් හි නිශ්චිතව දක්වා විචල්ය දෙකක් අතර අහඹු මුළු සංඛ්යා ජනනය කළ හැකිය x = 4සහ y = 8ඕනෑම ප්රතිදානය බව 4, 5, 6, 7, 8?

මොසිල්ලා සංවර්ධක ජාල පිටුවෙහි උදාහරණ කිහිපයක් තිබේ :

/**
 * 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).
 * The value is no lower than min (or the next integer greater than min
 * if min isn't an integer) and no greater than max (or the next integer
 * lower than max if max isn't an integer).
 * Using Math.round() will give you a non-uniform distribution!
 */
function getRandomInt(min, max) {
    min = Math.ceil(min);
    max = Math.floor(max);
    return Math.floor(Math.random() * (max - min + 1)) + min;
}

මෙන්න එහි පිටුපස ඇති තර්කනය. එය තුනක සරල රීතියකි:

Math.random()Number0 (ඇතුළත්) සහ 1 (විශේෂිත) අතර ප්‍රතිලාභයක් ලබා දෙයි . ඉතින් අපට මේ වගේ පරතරයක් තියෙනවා:

[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, ceilහෝ 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ඔබ සමඟ පරිපූර්ණ ඒකාකාර බෙදාහැරීමක් ඇත.

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ද හේතු.

var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;

Math.random ()

ප්රතිලාභ යනු පූර්ණ සංඛ්යාවකි අහඹු සංඛ්යාව විනාඩි (අතර ඇතුළත් ) සහ උපරිම ( ඇතුළත් ):

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

හෝ මිනි ( ඇතුළත් ) සහ උපරිම ( ඇතුළත් කර නැත ) අතර අහඹු අංකයක් :

function randomNumber(min, max) {
  return Math.random() * (max - min) + 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;

** සෑම විටම මතක් කිරීම සතුටක් (මොසිල්ලා):

Math.random () මගින් ගුප්ත විද්‍යාත්මකව ආරක්ෂිත අහඹු සංඛ්‍යා ලබා නොදේ. ආරක්ෂාව සම්බන්ධ කිසිවක් සඳහා ඒවා භාවිතා නොකරන්න. ඒ වෙනුවට වෙබ් ක්‍රිප්ටෝ API භාවිතා කරන්න, වඩාත් නිවැරදිව window.crypto.getRandomValues ​​() ක්‍රමය භාවිතා කරන්න.

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 අතර අහඹු ද්විත්ව ප්රතිලාභ, සහ එක් ප්ලස් අතර වෙනස අපට බොහෝ සෙයින් වැඩි නම් එය topහා bottomඅපි අතර ද්විත්ව කොහේ හරි අරගෙන දෙන්නම්, 0හා 1+b-a.

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එම ප්‍රති result ලයට පරාසය තුළ පූර්ණ සංඛ්‍යාවක් ලබා ගැනීම bottomසහ topඇතුළත් කිරීම පමණි. : ඩී

සටහන: ඔබ පූර්ණ සංඛ්‍යාවක් නොවන අගයකින් හෝ වැඩි සංඛ්‍යාවක් පසු කළහොත් පළමුව ඔබට නුසුදුසු හැසිරීමක් ලැබෙනු ඇත, නමුත් කිසිවෙකු එය ඉල්ලන්නේ නැත්නම් මම තර්ක පරික්ෂා කිරීමේ කේතය මුල් ප්‍රශ්නයේ අභිප්‍රායයට වඩා දුරින් සොයා බැලීමට යන්නේ නැත. .

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

විකල්පයක් නම් ඔබට භාවිතා කළ හැකි Underscore.js භාවිතා කරන්නේ නම්

_.random(min, max)

1 සහ 10 අතර අහඹු අංකයක් ආපසු එවන්න:

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

1 සහ 100 අතර අහඹු අංකයක් ආපසු එවන්න:

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

ඔබට 0 සහ උපරිම අතර විචල්‍යතාවයක් අවශ්‍ය නම් ඔබට මෙය භාවිතා කළ හැකිය:

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

අනෙක් පිළිතුරු ගෙවූ සාධාරණ පරාමිතීන් සඳහා වැයවේ නැහැ 0හා 1. ඒ වෙනුවට ඔබ භාවිතා කළ යුත්තේ round ඒ වෙනුවට ක ceilහෝ floor:

function randomNumber(minimum, maximum){
    return Math.round( Math.random() * (maximum - minimum) + minimum);
}

console.log(randomNumber(0,1));  # 0 1 1 0 1 0
console.log(randomNumber(5,6));  # 5 6 6 5 5 6
console.log(randomNumber(3,-1)); # 1 3 1 -1 -1 -1

දී ඇති පරාසය අතර අහඹු සංඛ්‍යා ලබා ගැනීමට මෙම ශ්‍රිතය භාවිතා කරන්න

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

ජාවාස්ක්‍රිප්ට් හි සසම්භාවී පන්තියේ MS ඩොට්නෙට් ක්‍රියාත්මක කිරීම මෙන්න

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

පරිගණක වැඩසටහනක් භාවිතයෙන් අහඹු අංකයක් ජනනය කිරීමෙන් පසුව, තෝරාගත් අංකය කොටසක් හෝ ආරම්භක අංකයේ සම්පූර්ණ එකක් නම් එය තවමත් අහඹු අංකයක් ලෙස සැලකේ. නමුත් එය වෙනස් කර ඇත්නම්, ගණිත ians යින් එය අහඹු අංකයක් ලෙස නොපිළිගන්නා අතර ඔවුන්ට එය පක්ෂග්‍රාහී අංකයක් ලෙස හැඳින්විය හැකිය. නමුත් ඔබ සරල කාර්යයක් සඳහා වැඩසටහනක් සංවර්ධනය කරන්නේ නම්, මෙය සලකා බැලිය යුතු කරුණක් නොවේ. නමුත් ඔබ ලොතරැයි වැඩසටහන හෝ සූදු ක්‍රීඩාව වැනි වටිනා දේවල් සඳහා අහඹු අංකයක් ජනනය කිරීමේ වැඩසටහනක් සංවර්ධනය කරන්නේ නම්, ඉහත සිද්ධිය ගැන ඔබ නොසලකන්නේ නම් ඔබේ වැඩසටහන කළමනාකාරිත්වය විසින් ප්‍රතික්ෂේප කරනු ලැබේ.

ඉතින් ඒ වගේ අය සඳහා, මෙන්න මගේ යෝජනාව:

භාවිතා කරමින් අහඹු අංකයක් ජනනය කරන්න 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 සහ එසේ ගුණ කිරීම) මා මුලින් සඳහන් කළ ක්‍රමය උල්ලං not නය නොවන බව (එය වෙනස් වන නිසා දශම ලක්ෂ්‍යයේ ස්ථානය.)

පහත උදාහරණය අධ්‍යයනය කර ඔබේ අවශ්‍යතා අනුව එය දියුණු කරන්න.

ඔබට නියැදියක් අවශ්‍ය නම් [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);

සටහන: පළමු ක්‍රමයේදී, පළමුව මම ඔබට අවශ්‍ය සංඛ්‍යා අඩංගු අරාවක් නිර්මාණය කර අහඹු ලෙස වෙනත් අරාවකට දැමුවෙමි. දෙවන ක්‍රමයේදී, අහඹු ලෙස සංඛ්‍යා උත්පාදනය කර ඔබට අවශ්‍ය පරාසයේ ඒවා තිබේදැයි පරීක්ෂා කරන්න. ඉන්පසු එය අරාවකට දමන්න. මෙහිදී මම අහඹු සංඛ්‍යා දෙකක් ජනනය කළ අතර ප්‍රයෝජනවත් සංඛ්‍යාවක් ලබා ගැනීමේ අසාර්ථක අනුපාතය අවම කිරීමෙන් වැඩසටහනේ වේගය උපරිම කිරීමට ඒවා භාවිතා කළෙමි. කෙසේ වෙතත් ජනනය කරන ලද සංඛ්‍යා එකතු කිරීමෙන් යම් පක්ෂග්‍රාහී බවක් ලැබෙනු ඇත. එබැවින් නිශ්චිත පරාසයක් තුළ අහඹු සංඛ්‍යා උත්පාදනය කිරීම සඳහා මගේ පළමු ක්‍රමය නිර්දේශ කරමි.

ක්‍රම දෙකෙහිම, ඔබේ කොන්සෝලය ප්‍රති result ලය පෙන්වනු ඇත (කොන්සෝලය විවෘත කිරීමට Chrome හි f12 ඔබන්න)

පරාසයක් සහිත අහඹු පූර්ණ සංඛ්‍යාවක් සඳහා, උත්සාහ කරන්න:

function random(minimum, maximum) {
  var bool = true;

  while (bool) {
    var number = (Math.floor(Math.random() * maximum + 1) + minimum);
    if (number > 20) {
      bool = true;
    } else {
      bool = false;
    }
  }

  return number;
}

function getRandomInt(lower, upper)
{
    //to create an even sample distribution
    return Math.floor(lower + (Math.random() * (upper - lower + 1)));

    //to produce an uneven sample distribution
    //return Math.round(lower + (Math.random() * (upper - lower)));

    //to exclude the max value from the possible values
    //return Math.floor(lower + (Math.random() * (upper - lower)));
}

මෙම ශ්‍රිතය සහ මෙම ශ්‍රිතයේ වෙනස්කම් පරීක්ෂා කිරීම සඳහා, පහත HTML / JavaScript ගොනුවකට සුරකින්න සහ බ්‍රව්සරයකින් විවෘත කරන්න. කේතය මඟින් ක්‍රියාකාරී ඇමතුම් මිලියනයක් බෙදා හැරීම පෙන්වන ප්‍රස්ථාරයක් නිපදවනු ඇත . කේතය දාරයේ අවස්ථා වාර්තා කරයි, එබැවින් ශ්‍රිතය උපරිමයට වඩා වැඩි අගයක් හෝ මිනිත්තුවට වඩා අඩු අගයක් නිපදවන්නේ නම්, you.will.know.about.it.

<html>
    <head>
        <script type="text/javascript">
        function getRandomInt(lower, upper)
        {
            //to create an even sample distribution
            return Math.floor(lower + (Math.random() * (upper - lower + 1)));

            //to produce an uneven sample distribution
            //return Math.round(lower + (Math.random() * (upper - lower)));

            //to exclude the max value from the possible values
            //return Math.floor(lower + (Math.random() * (upper - lower)));
        }

        var min = -5;
        var max = 5;

        var array = new Array();

        for(var i = 0; i <= (max - min) + 2; i++) {
          array.push(0);
        }

        for(var i = 0; i < 1000000; i++) {
            var random = getRandomInt(min, max);
            array[random - min + 1]++;
        }

        var maxSample = 0;
        for(var i = 0; i < max - min; i++) {
            maxSample = Math.max(maxSample, array[i]);
        }

        //create a bar graph to show the sample distribution
        var maxHeight = 500;
        for(var i = 0; i <= (max - min) + 2; i++) {
            var sampleHeight = (array[i]/maxSample) * maxHeight;

            document.write('<span style="display:inline-block;color:'+(sampleHeight == 0 ? 'black' : 'white')+';background-color:black;height:'+sampleHeight+'px">&nbsp;[' + (i + min - 1) + ']:&nbsp;'+array[i]+'</span>&nbsp;&nbsp;');
        }
        document.write('<hr/>');
        </script>
    </head>
    <body>

    </body>
</html>

අහඹු අංකයක් ලබා ගැනීමට 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 ක් ඉවත් කිරීමෙන් ඔබ මූලිකවම උපරිම අගය වටකුරු වීම වළක්වයි.

උපකාරවත් වන බලාපොරොත්තුව.

පහත දැක්වෙන කේතය භාවිතා කිරීමෙන් ඔබට යම් පරාසයක පුනරාවර්තනය නොවී අහඹු සංඛ්‍යා පෙළක් ජනනය කළ හැකිය.

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;
        }

මෙම ප්‍රශ්නයට දැනටමත් පිළිතුරු ලැබී ඇති බව මම දනිමි, නමුත් මගේ පිළිතුර යමෙකුට උපකාර කළ හැකිය.

W3 පාසැල් වල මෙම සරල ක්‍රමය මට හමු විය:

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

මෙය යමෙකුට උපකාරී වේ යැයි සිතමි.

අවම සහ ඉහළම අතර අහඹු මුළු අංකය:

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

වඩාත්ම අලංකාර විසඳුම නොවේ .. නමුත් ඉක්මන් දෙයක්.

අහඹු සංඛ්‍යා උත්පාදනය කිරීමට මා භාවිතා කරන්නේ මෙන්න.

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

ක්‍රිප්ටෝ-ශක්තිමත්

රග්නේ [x, y] හි ගුප්ත-ශක්තිමත් අහඹු සංඛ්‍යා සංඛ්‍යාවක් ලබා ගැනීමට උත්සාහ කරන්න

let cs= (x,y)=>x+(y-x+1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32|0

console.log(cs(4,8))

    <!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 ක් වේ. මෙම කේතය ඉතා කෙටි වේ.

Math.random () භාවිතා නොකර ඕනෑම නිශ්චිත දිගක අහඹු සංඛ්‍යාවක් ජනනය කළ හැකි javascript ශ්‍රිතයක උදාහරණයක් මෙන්න :

    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;
    }

අහඹු අංකයක් on ාතයට පාදක පරාසයක් තුළ ලබා ගැනීමට මට අවශ්‍ය වූවාක් මෙන් මෙය පරාසයක අහඹු අංකයක් ලබා ගැනීමකි. උදා: base = 10, on ාත = 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);

Math.random() බොහෝ අරමුණු සඳහා වේගවත් හා සුදුසු ය, නමුත් ඔබට ගුප්ත විද්‍යාත්මකව ආරක්ෂිත අගයන් අවශ්‍ය නම් එය සුදුසු නොවේ (එය ආරක්ෂිත නොවේ), හෝ ඔබට සම්පූර්ණයෙන්ම ඒකාකාරී අපක්ෂපාතී බෙදාහැරීමකින් පූර්ණ සංඛ්‍යා අවශ්‍ය නම් (අනෙක් අය භාවිතා කරන ගුණ කිරීමේ ප්‍රවේශය මඟින් ඇතැම් අගයන් තරමක් වැඩි වාර ගණනක් නිපදවයි අනෙක් අයට වඩා).

එවැනි අවස්ථාවන්හිදී, අපට crypto.getRandomValues()ආරක්ෂිත පූර්ණ සංඛ්‍යා උත්පාදනය කිරීමට භාවිතා කළ හැකි අතර, ඉලක්කගත පරාසයට ඒකාකාරව සිතියම් ගත කළ නොහැකි ජනනය කළ අගයන් ප්‍රතික්ෂේප කරන්න. මෙය මන්දගාමී වනු ඇත, නමුත් ඔබ අතිශයින් විශාල අගයන් උත්පාදනය කරන්නේ නම් මිස එය සැලකිය යුතු නොවේ.

පක්ෂග්‍රාහී බෙදා හැරීමේ උත්සුකය පැහැදිලි කිරීම සඳහා, අපට 1 සහ 5 අතර අගයක් ජනනය කිරීමට අවශ්‍ය අවස්ථාව සලකා බලන්න, නමුත් අපට අහඹු සංඛ්‍යා උත්පාදක යන්ත්‍රයක් ඇති අතර එය 1 සහ 16 අතර අගයන් නිපදවයි (4-බිට් අගය). එක් එක් නිමැවුම් අගයට සමාන උත්පාදක අගයන් සිතියම් ගත කිරීමට අපට අවශ්‍යය, නමුත් 16 ඒකාකාරව 5 න් බෙදන්නේ නැත: එය ඉතිරි 1 න් ඉතිරි වේ. එබැවින් අපට ජනනය කළ හැකි අගයන්ගෙන් 1 ක් ප්‍රතික්ෂේප කළ යුතු අතර, අපට ලැබෙන විට පමණක් ඉදිරියට යන්න අපගේ ඉලක්ක පරාසයට ඒකාකාරව සිතියම් ගත කළ හැකි අඩු අගයන් 15 න් එකක්. අපගේ හැසිරීම මෙම ව්‍යාජ කේතය මෙන් විය හැකිය:

Generate a 4-bit integer in the range 1-16.
If we generated  1,  6, or 11 then output 1.
If we generated  2,  7, or 12 then output 2.
If we generated  3,  8, or 13 then output 3.
If we generated  4,  9, or 14 then output 4.
If we generated  5, 10, or 15 then output 5.
If we generated 16 then reject it and try again.

පහත කේතය සමාන තර්කනයක් භාවිතා කරයි, නමුත් ඒ වෙනුවට බිටු 32 ක පූර්ණ සංඛ්‍යාවක් ජනනය කරයි, මන්ද එය ජාවාස්ක්‍රිප්ට්හි සම්මත numberවර්ගය මගින් නිරූපණය කළ හැකි විශාලතම පොදු පූර්ණ සංඛ්‍යා ප්‍රමාණයයි . ( BigIntඔබට විශාල පරාසයක් අවශ්‍ය නම් s භාවිතා කිරීම සඳහා මෙය වෙනස් කළ හැකිය .) තෝරාගත් පරාසය කුමක් වුවත්, ප්‍රතික්ෂේප කරන ලද උත්පාදනය කළ අගයන්හි භාගය සෑම විටම 0.5 ට වඩා අඩු වනු ඇත, එබැවින් අපේක්ෂිත ප්‍රතික්ෂේප කිරීම් සංඛ්‍යාව සැමවිටම 1.0 ට වඩා අඩු වනු ඇත. සාමාන්‍යයෙන් 0.0 ට ආසන්නයි; එය සදහටම ලූප වීම ගැන ඔබට කරදර විය යුතු නැත.

const randomInteger = (min, max) => {
  const range = max - min;
  const maxGeneratedValue = 0xFFFFFFFF;
  const possibleResultValues = range + 1;
  const possibleGeneratedValues = maxGeneratedValue + 1;
  const remainder = possibleGeneratedValues % possibleResultValues;
  const maxUnbiased = maxGeneratedValue - remainder;

  if (!Number.isInteger(min) || !Number.isInteger(max) ||
       max > Number.MAX_SAFE_INTEGER || min < Number.MIN_SAFE_INTEGER) {
    throw new Error('Arguments must be safe integers.');
  } else if (range > maxGeneratedValue) {
    throw new Error(`Range of ${range} (from ${min} to ${max}) > ${maxGeneratedValue}.`);
  } else if (max < min) {
    throw new Error(`max (${max}) must be >= min (${min}).`);
  } else if (min === max) {
    return min;
  } 

  let generated;
  do {
    generated = crypto.getRandomValues(new Uint32Array(1))[0];
  } while (generated > maxUnbiased);

  return min + (generated % possibleResultValues);
};

console.log(randomInteger(-8, 8));          // -2
console.log(randomInteger(0, 0));           // 0
console.log(randomInteger(0, 0xFFFFFFFF));  // 944450079
console.log(randomInteger(-1, 0xFFFFFFFF));
// Error: Range of 4294967296 covering -1 to 4294967295 is > 4294967295.
console.log(new Array(12).fill().map(n => randomInteger(8, 12)));
// [11, 8, 8, 11, 10, 8, 8, 12, 12, 12, 9, 9]

මෙම සියලු විසඳුම් ඕනෑවට වඩා ෆයර් පවර් භාවිතා කරයි, ඔබට අවශ්‍ය වන්නේ එක් ශ්‍රිතයක් පමණි: Math.random ();

Math.random() * max | 0;

මෙය 0 (ඇතුළත්) සහ උපරිම (ඇතුළත් නොවන) අතර අහඹු int එකක් ලබා දෙයි:

ඔබට මෙම කේත ස්නිපටය කළ හැකිය,

let randomNumber = function(first,second){
let number = Math.floor(Math.random()*Math.floor(second));
while(number<first){

    number = Math.floor(Math.random()*Math.floor(second));
}
return number;
}

අයෝනු ජී. ස්ටැන් හොඳ පිළිතුරක් ලිවූ නමුත් එය මට තේරුම් ගැනීමට නොහැකි තරමට සංකීර්ණ විය. එබැවින්, ජේසන් ඇනෙලෝ විසින් https://teamtreehouse.com/community/mathfloor-mathrandom-max-min-1-min-explanation වෙතින් එකම සංකල්ප පිළිබඳ වඩාත් සරල පැහැදිලි කිරීමක් මට හමු විය .

සටහන: ජේසන්ගේ පැහැදිලි කිරීම කියවීමට පෙර ඔබ දැනගත යුතු එකම වැදගත් දෙය වන්නේ “කප්පාදු කිරීම” යන්නයි. විස්තර කිරීමේදී ඔහු එම පදය භාවිතා කරයි Math.floor(). ඔක්ස්ෆර්ඩ් ශබ්දකෝෂය “කප්පාදු කිරීම” ලෙස අර්ථ දක්වන්නේ:

ඉහළ හෝ කෙළවර කපා දැමීමෙන් (යමක්) කෙටි කරන්න.

මෙමඟින් ඉලක්කම් 20 දක්වා UNIQUE අහඹු අංකයක් උත්පාදනය කළ හැකිය

ජේ

var generatedNumbers = [];

function generateRandomNumber(precision) { // precision --> number precision in integer 
    if (precision <= 20) {
        var randomNum = Math.round(Math.random().toFixed(precision) * Math.pow(10, precision));
        if (generatedNumbers.indexOf(randomNum) > -1) {
            if (generatedNumbers.length == Math.pow(10, precision))
                return "Generated all values with this precision";
                return generateRandomNumber(precision);
        } else {
            generatedNumbers.push(randomNum);
            return randomNum;
        }
    } else
       return "Number Precision shoould not exceed 20";
}
generateRandomNumber(1);

JsFiddle

/ * randUpToඅංකයක් පිළිගෙන 0 සහ එම සංඛ්‍යාව අතර අහඹු සම්පූර්ණ සංඛ්‍යාවක් ලබා දෙන ශ්‍රිතයක් ලියන්න ? * /

var randUpTo = function(num) {
    return Math.floor(Math.random() * (num - 1) + 0);
};

/ * randBetweenපරාසයක් නියෝජනය කරන සංඛ්‍යා දෙකක් පිළිගෙන එම සංඛ්‍යා දෙක අතර අහඹු සම්පූර්ණ සංඛ්‍යාවක් ලබා දෙන ශ්‍රිතයක් ලියන්න . * /

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

/ * randFromTillපරාසයක් නියෝජනය කරන අංක දෙකක් පිළිගෙන මිනිත්තු (ඇතුළත්) සහ උපරිම (සුවිශේෂී) අතර අහඹු අංකයක් ලබා දෙන ශ්‍රිතයක් ලියන්න . * /

var randFromTill = function (min, max) {
    return Math.random() * (max - min) + min;
};

/ * randFromToපරාසයක් නියෝජනය කරන සංඛ්‍යා දෙකක් පිළිගෙන මිනිත්තු (ඇතුළත්) සහ උපරිම (ඇතුළත්) අතර අහඹු සංඛ්‍යාවක් ලබා දෙන ශ්‍රිතයක් ලියන්න * /

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

මම මෙම ක්‍රියාව සිදු කළේ මිනි, මැක්ස්, බැහැර කිරීම (බැහැර කිරීමට අඟල් ලැයිස්තුවක්) සහ බීජ (ඔබට බීජ සහිත අහඹු උත්පාදක යන්ත්‍රයක් අවශ්‍ය නම්) වැනි විකල්පයන් සැලකිල්ලට ගනිමිනි.

get_random_int = function(args={})
{
    let def_args =
    {
        min: 0,
        max: 1,
        exclude: false,
        seed: Math.random
    }

    args = Object.assign(def_args, args)

    let num = Math.floor(args.seed() * (args.max - args.min + 1) + args.min)

    if(args.exclude)
    {
        let diff = args.max - args.min
        let n = num

        for(let i=0; i<diff*2; i++)
        {
            if(args.exclude.includes(n))
            {
                if(n + 1 <= args.max)
                {
                    n += 1
                }

                else
                {
                    n = args.min
                }
            }

            else
            {
                num = n
                break
            }
        }
    }

    return num
}

එය පහත පරිදි භාවිතා කළ හැකිය:

let n = get_random_int
(
    {
        min: 0,
        max: some_list.length - 1,
        exclude: [3, 6, 5],
        seed: my_seed_function
    }
)

හෝ වඩාත් සරලව:

let n = get_random_int
(
    {
        min: 0,
        max: some_list.length - 1
    }
)

එවිට ඔබට කළ හැකිය:

let item = some_list[n]

සාරාංශය: https://gist.github.com/madprops/757deb000bdec25776d5036dae58ee6e

• සසම්භාවී (මිනි, උපරිම) මිනි (ඇතුළත්) සහ උපරිම (සුවිශේෂී) අතර අහඹු සංඛ්‍යාවක් ජනනය කරයි

• Math.floor ආසන්න සංඛ්‍යාවක් දක්වා අංකයක් වට කරයි

  function generateRandomInteger (min, max) { 
      return Math.floor(random(min,max)) 
  }`

එබැවින් 4 ත් 8 ත් අතර අහඹු පූර්ණ සංඛ්‍යාවක් ජනනය කිරීම සඳහා, ඉහත ශ්‍රිතය පහත දැක්වෙන තර්ක සමඟ අමතන්න:

generateRandomInteger (4,9)