ජාවාස්ක්‍රිප්ට් හි නිශ්චිත පරාසයක (උදා: 1 සිට 6: 1, 2, 3, 4, 5, හෝ 6 දක්වා) අහඹු අංකයක් ජනනය කිරීමට ක්‍රමයක් තිබේද?

වැදගත්

පහත කේතය ක්‍රියාත්මක වන්නේ අවම අගය නම් පමණි 1. එය හැර අවම අගයන් සඳහා ක්‍රියා නොකරයි 1.

1 ( සහ 1 පමණක් ) සහ 6 අතර අහඹු සංඛ්‍යාවක් ලබා ගැනීමට ඔබට අවශ්‍ය නම් , ඔබ ගණනය කරන්නේ:

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

කොහෙද:

• 1 යනු ආරම්භක අංකයයි
• 6 යනු හැකි ප්‍රති results ල ගණන (1 + ආරම්භය (6) - අවසානය (1) )

function randomIntFromInterval(min, max) { // min and max included 
  return Math.floor(Math.random() * (max - min + 1) + min);
}

එය "අතිරේක" කරන්නේ 1 සමඟ ආරම්භ නොවන අහඹු කාල පරතරයන්ට ඉඩ දීමයි. එබැවින් ඔබට අහඹු අංක 10 සිට 15 දක්වා ලබා ගත හැකිය. නම්‍යශීලී බව.

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 () මගින් ගුප්ත විද්‍යාත්මකව ආරක්ෂිත අහඹු සංඛ්‍යා ලබා නොදේ. ආරක්ෂාව සම්බන්ධ කිසිවක් සඳහා ඒවා භාවිතා නොකරන්න. ඒ වෙනුවට වෙබ් ක්‍රිප්ටෝ ඒපීඅයි භාවිතා කරන්න, වඩාත් නිවැරදිව window.crypto.getRandomValues ​​() ක්‍රමය භාවිතා කරන්න.

වෙනත් විසඳුම්:

• (Math.random() * 6 | 0) + 1
• ~~(Math.random() * 6) + 1

මාර්ගගතව උත්සාහ කරන්න

ටීඑල්; ඩී.ආර්

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

අහඹු අංකය ලබා ගැනීමට generateRandomInteger(-20, 20);

පහත පැහැදිලි කිරීම

අපට අහඹු සංඛ්‍යාවක් ලබා ගත යුතුය, මිනිත්තු සහ උපරිම අතර X යැයි කියන්න .

හරිද?

එනම් මිනි <= X <= උපරිම

අපි සමීකරණයෙන් මිනිත්තුව අඩු කළහොත් මෙය සමාන වේ

0 <= (X - min) <= (උපරිම - මිනි)

දැන්, අහඹු සංඛ්යාවක් සමග ගුණ ඉඩ දෙනවා r වන

0 <= (X - min) * r <= (උපරිම - min) * r

දැන්, සමීකරණයට මිනිත්තුව නැවත එකතු කරමු

min <= min + (X - min) * r <= min + (උපරිම - min) * r

දැන්, r හි ප්‍රති results ලයක් වන ශ්‍රිතයක් තෝරා ගැනීමට ඉඩ දෙන්න, එය අපගේ සමීකරණ පරාසය [min, max] ලෙස තෘප්තිමත් කරයි. මෙය කළ හැක්කේ 0 <= r <= 1 නම් පමණි

හරි. දැන්, r එනම් [0,1] පරාසය Math.random () ක්‍රියාකාරී ප්‍රති .ලයට බෙහෙවින් සමාන ය. එසේ නොවේ ද?

Math.random () ශ්‍රිතය පරාසයේ පාවෙන ලක්ෂ්‍ය, ව්‍යාජ සසම්භාවී අංකයක් ලබා දෙයි [0, 1); එනම්, 0 (ඇතුළත්) සිට 1 දක්වා (1) ඇතුළත් නොවේ

උදාහරණයක් වශයෙන්,

නඩුව r = 0

min+ 0 * ( max- min) = මිනි

නඩුව r = 1

min+ 1 * ( max- min) = උපරිම

Math.random 0 <= r <1 භාවිතා කරමින් අහඹු නඩුව

min+ r * ( max- min) = X , එහිදී X හි මිනි <= X < උපරිම පරාසයක් ඇත

ඉහත ප්‍රති result ලය X යනු අහඹු සංඛ්‍යා වේ. කෙසේ වෙතත් Math.random () නිසා අපගේ වම් සීමාව ඇතුළත් වන අතර දකුණු සීමාව සුවිශේෂී වේ. අපගේ දකුණු සීමාව ඇතුළත් කිරීම සඳහා අපි දකුණු සීමාව 1 කින් වැඩි කර ප්‍රති .ලය ලබා දෙන්නෙමු.

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

අහඹු අංකය ලබා ගැනීමට

generateRandomInteger(-20, 20);

නැත්නම්, අන්ඩර්ස්කෝර් හි

_.random(min, max)

var x = 6; // can be any number
var rand = Math.floor(Math.random()*x) + 1;

jsfiddle: https://jsfiddle.net/cyGwf/477/

සසම්භාවී පූර්ණ සංඛ්‍යා : minසහ අතර අහඹු සංඛ්‍යාවක් ලබා ගැනීමට max, පහත කේතය භාවිතා කරන්න

function getRandomInteger(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min)) + min;
}

අහඹු ඉපිලුම් ලක්ෂ්ය අංකය : අතර අහඹු ඉපිලුම් ලක්ෂ්ය සංඛ්යාව ලබා ගැනීමට minසහ max, පහත දැක්වෙන කේතය භාවිතා

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

යොමුව: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random

ගණිතය මගේ ප්‍රබල කාරණය නොවේ, නමුත් මම ධනාත්මක හා .ණාත්මක අතර අහඹු සංඛ්‍යා රාශියක් ජනනය කිරීමට අවශ්‍ය ව්‍යාපෘතියක වැඩ කරමින් සිටිමි.

function randomBetween(min, max) {
    if (min < 0) {
        return min + Math.random() * (Math.abs(min)+max);
    }else {
        return min + Math.random() * max;
    }
}

උදා

randomBetween(-10,15)//or..
randomBetween(10,20)//or...
randomBetween(-200,-100)

ඇත්ත වශයෙන්ම, අංක හැර වෙනත් කිසිවක් සමඟ ඔබ මෙය නොකරන බවට වග බලා ගැනීම සඳහා ඔබට යම් වලංගු භාවයක් එක් කළ හැකිය. මිනිත්තුව සෑම විටම උපරිමයට වඩා අඩු හෝ සමාන බව සහතික කරගන්න.

මම වඩාත් නම්‍යශීලී ශ්‍රිතයක් ලියා ඇති අතර එමඟින් ඔබට අහඹු සංඛ්‍යාවක් ලබා දිය හැකි නමුත් පූර්ණ සංඛ්‍යාවක් පමණක් නොවේ.

function rand(min,max,interval)
{
    if (typeof(interval)==='undefined') interval = 1;
    var r = Math.floor(Math.random()*(max-min+interval)/interval);
    return r*interval+min;
}

var a = rand(0,10); //can be 0, 1, 2 (...) 9, 10
var b = rand(4,6,0.1); //can be 4.0, 4.1, 4.2 (...) 5.9, 6.0

ස්ථාවර අනුවාදය.

උදාහරණයක්

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

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

ප්‍රති result ලය විය හැක්කේ: 3

ඔබම උත්සාහ කරන්න: මෙන්න

-

හෝ lodash / undescore භාවිතා කිරීම:

_.random(min, max)

ලියකියවිලි: - ලොඩාෂ් - අවිනිශ්චිත

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

    Rand(min: number, max: number): number {
        return (Math.random() * (max - min + 1) | 0) + min;
    }   

බොහෝ පිළිතුරු සහ එකම ප්‍රති .ල ලබා දෙන්න. මම මගේ පිළිතුර එකතු කර එහි ක්‍රියාකාරිත්වය පැහැදිලි කිරීමට කැමතියි. එක් පේළි කේතයක් පිටපත් කිරීම වෙනුවට එහි ක්‍රියාකාරිත්වය තේරුම් ගැනීම වැදගත් බැවිනි. අහඹු සංඛ්‍යා උත්පාදනය කිරීම සරල ගණිතයක් මිස අන් කිසිවක් නොවේ.

කේතය:

function getR(lower, upper) {

  var percent = (Math.random() * 100);
  // this will return number between 0-99 because Math.random returns decimal number from 0-0.9929292 something like that
  //now you have a percentage, use it find out the number between your INTERVAL :upper-lower 
  var num = ((percent * (upper - lower) / 100));
  //num will now have a number that falls in your INTERVAL simple maths
  num += lower;
  //add lower to make it fall in your INTERVAL
  //but num is still in decimal
  //use Math.floor>downward to its nearest integer you won't get upper value ever
  //use Math.ceil>upward to its nearest integer upper value is possible
  //Math.round>to its nearest integer 2.4>2 2.5>3   both lower and upper value possible
  console.log(Math.floor(num), Math.ceil(num), Math.round(num));
}

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]

@ ෆ්‍රැන්සිස්ක්ගේ පිළිතුරෙහි floatඅනුවාදය මත පදනම්ව ස්ථාවර නිරවද්‍ය අනුවාදයක් සමඟ එකතු කිරීම int:

function randomFloatFromInterval (min, max, fractionDigits) {
  const fractionMultiplier = Math.pow(10, fractionDigits)
  return Math.round(
    (Math.random() * (max - min) + min) * fractionMultiplier,
  ) / fractionMultiplier
}

නිසා:

randomFloatFromInterval(1,3,4) // => 2.2679, 1.509, 1.8863, 2.9741, ...

සහ int පිළිතුර සඳහා

randomFloatFromInterval(1,3,0) // => 1, 2, 3

[A, b] පරාසයේ ඇති ක්‍රිප්ටෝ-ශක්තිමත් අහඹු පූර්ණ සංඛ්‍යා අංකය (උපකල්පනය: a <b)

let rand= (a,b)=> a+(b-a+1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32|0

console.log( rand(1,6) );

භාවිතා කිරීමට උත්සාහ කරන්න:

function random(min, max) {
   return Math.round((Math.random() *( Math.abs(max - min))) + min);
}
console.log(random(1, 6));

මෙය ක්‍රියාත්මක විය යුතුය:

const getRandomNum = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min

ES6 පෙරනිමි පරාමිතීන් භාවිතා කරමින් මෙය කිරීමට හොඳ නව ක්‍රමයක් මම සොයා ගතිමි. එය එක් තර්කයක් හෝ තර්ක දෙකකට ඉඩ දෙන බැවින් එය ඉතා නිර්‍මාණ වේ. මේ තියෙන්නේ:

function random(n, b = 0) {
    return Math.random() * (b-n) + n;
}

මෙය වසර නවයක් පමණ ප්‍රමාදයි, නමුත් randojs.com මෙය සරල එක් ලයිනර් එකක් කරයි:

rando(1, 6)

ඔබට මෙය ඔබගේ html ලේඛනයේ හිසට එක් කළ යුතු අතර අහඹු ලෙස ඔබට අවශ්‍ය ඕනෑම දෙයක් පහසුවෙන් කළ හැකිය. අරා වලින් අහඹු අගයන්, අහඹු jquery මූලද්‍රව්‍ය, වස්තූන්ගෙන් අහඹු ගුණාංග සහ අවශ්‍ය නම් පුනරාවර්තනය වීම පවා වළක්වයි.

<script src="https://randojs.com/1.0.0.js"></script>

මෙය මට වැඩ කරන අතර පයිතන්ගේ අහඹු.රැන්ඩිං සම්මත පුස්තකාල ශ්‍රිතය වැනි අගයන් නිෂ්පාදනය කරයි :

function randint(min, max) {
   return Math.round((Math.random() * Math.abs(max - min)) + min);
}

console.log("Random integer: " + randint(-5, 5));

මූලික වශයෙන් ඩයිස් එකක් මෙන් 1-6 ක් ආපසු යාමට,

return Math.round(Math.random() * 5 + 1);