मैं जावास्क्रिप्ट में दो निर्दिष्ट चर के बीच यादृच्छिक पूरी संख्या कैसे उत्पन्न कर सकता हूं, उदा 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वापस जोड़ना न भूलें , ताकि हमें [min, max) अंतराल में एक नंबर मिले:
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 maxmaxअंतराल से बाहर रखने के साथ , यह रोल करने के लिए एक भी कम मौका है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भी उत्पन्न होती हैं।
floor, जो नीचे गोल है।
round, लेकिन फिर दोनों, minऔर maxकेवल आधी संख्या में अन्य संख्याओं की तरह रोल करने का मौका था। आप एक को भी ले सकते हैं और ले सकते हैं ceil। यह हालांकि अंतराल के maxकारण रोल करने की न्यूनतम कम संभावना के साथ संख्या को छोड़ देता है [0,1)।
var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;(Math.random() * (maximum - minimum + 1) ) << 0तेज है।
x << 0, x | 0, ~~x) के बजाय Math.floor()धर्मान्तरित xतुलना में काफी छोटा सीमा के साथ एक दो पूरक में Number.MAX_SAFE_INTEGER(2³²⁻¹ बनाम 2⁵³), इस प्रकार आप सावधानी के साथ इसका इस्तेमाल करने के लिए है!
657348096152|0218099864 (1100111111111111000010011000 बाइनरी में) प्राप्त करते हैं।
मिनट ( शामिल ) और अधिकतम ( शामिल ) के बीच एक पूर्णांक यादृच्छिक संख्या देता है :
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 () विधि।
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)तो हम श्रेणी में एक पूर्णांक नीचे दौर और प्राप्त कर सकते हैं 0करने के लिएtop-bottom
Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottomपिछले उदाहरण के कोड ने हमें सीमा में एक पूर्णांक दिया 0और top-bottomइसलिए, अब हमें केवल इतना करना bottomहै कि सीमा bottomऔर पूर्णांक में पूर्णांक प्राप्त करने के लिए उस परिणाम को जोड़ दें top। : डी
नोट: यदि आप एक गैर-पूर्णांक मान या अधिक संख्या में पास होते हैं, तो आपको अवांछनीय व्यवहार मिलेगा, लेकिन जब तक कोई भी यह अनुरोध नहीं करता है कि मैं मूल प्रश्न के इरादे से तर्क कोड की जांच करने में असमर्थ हूं। ।
function randomRange(min, max) {
return ~~(Math.random() * (max - min + 1)) + min
}वैकल्पिक यदि आप अंडरस्कोर का उपयोग कर रहे हैं। जेएस आप उपयोग कर सकते हैं
_.random(min, max)_.uniqueId()फ़ंक्शन प्रदान करता है जिसे आप क्लाइंट साइड मॉडल के लिए कॉल कर सकते हैं।
x << 0, x | 0, ~~x) के बजाय Math.floor()धर्मान्तरित xतुलना में काफी छोटा सीमा के साथ एक दो पूरक में Number.MAX_SAFE_INTEGER(2³²⁻¹ बनाम 2⁵³), इस प्रकार आप सावधानी के साथ इसका इस्तेमाल करने के लिए है!
1 और 10 के बीच एक यादृच्छिक संख्या लौटाएँ:
Math.floor((Math.random()*10) + 1); 1 और 100 के बीच एक यादृच्छिक संख्या लौटाएँ:
Math.floor((Math.random()*100) + 1)अन्य उत्तर की पूरी तरह से उचित मानकों के लिए खाते में नहीं है 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 -1console.log(randomNumber(5,6)); # 9 6 6 5 7 7क्या 9 और 7 5 और 6 के बीच आते हैं? ...... आप इसे ठीक करें या समझाएँ ..
यहाँ जावास्क्रिप्ट में रैंडम क्लास का एमएस डॉटनेट कार्यान्वयन है-
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दिए गए रेंज के बीच यादृच्छिक संख्या प्राप्त करने के लिए इस फ़ंक्शन का उपयोग करें
function rnd(min,max){
return Math.floor(Math.random()*(max-min+1)+min );
}कंप्यूटर प्रोग्राम का उपयोग करके एक यादृच्छिक संख्या उत्पन्न करने के बाद, यह अभी भी एक यादृच्छिक संख्या के रूप में माना जाता है अगर उठाया संख्या प्रारंभिक एक का एक हिस्सा या पूर्ण है। लेकिन अगर इसे बदल दिया गया, तो गणितज्ञ इसे एक यादृच्छिक संख्या के रूप में स्वीकार नहीं करते हैं और वे इसे एक पक्षपाती संख्या कह सकते हैं। लेकिन अगर आप एक सरल कार्य के लिए एक कार्यक्रम विकसित कर रहे हैं, तो यह विचार करने का मामला नहीं होगा। लेकिन यदि आप लॉटरी कार्यक्रम, या जुआ खेल जैसे मूल्यवान सामान के लिए एक यादृच्छिक संख्या उत्पन्न करने के लिए एक कार्यक्रम विकसित कर रहे हैं, तो आपके कार्यक्रम को प्रबंधन द्वारा खारिज कर दिया जाएगा यदि आप उपरोक्त मामले के बारे में विचार नहीं कर रहे हैं।
तो उन तरह के लोगों के लिए, यहाँ मेरा सुझाव है:
एक यादृच्छिक संख्या का उपयोग कर उत्पन्न करें 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] में पक्षपाती हैं, लेकिन फिर भी यह एक यादृच्छिक है अगर और केवल अगर मृत्यु निष्पक्ष है ।)
तो अपनी सीमा पर विचार करें ==> [=,, २४ your] श्रेणी के तत्वों की संख्या = २४ 78 - 1 + १ = १ ;०; (चूँकि दोनों सीमाएँ सम्मिलित हैं।
/*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);नोट: विधि एक में, पहले मैंने एक सरणी बनाई जिसमें संख्याएं हैं जिनकी आपको आवश्यकता है और फिर उन्हें यादृच्छिक रूप से किसी अन्य सरणी में डालें। विधि दो में, संख्याओं को बेतरतीब ढंग से जनरेट करें और जाँचें कि आपकी ज़रूरत की सीमा क्या है। फिर इसे एक सरणी में रखें। यहाँ मैंने दो यादृच्छिक संख्याएँ उत्पन्न कीं और उनमें से कुल का उपयोग करके एक उपयोगी संख्या प्राप्त करने में विफलता दर को कम करके कार्यक्रम की गति को अधिकतम किया। हालाँकि उत्पन्न संख्याओं को जोड़ना भी कुछ पूर्वाग्रह देगा। इसलिए मैं एक विशिष्ट सीमा के भीतर यादृच्छिक संख्या उत्पन्न करने के लिए अपनी पहली विधि की सिफारिश करूंगा।
दोनों विधियों में, आपका कंसोल परिणाम दिखाएगा। (कंसोल खोलने के लिए Chrome में f12 दबाएं)
Math.floor(Math.random() * (6 - 1 + 1) + 1)] के साथ 1 और 6 नंबर जरूरी 2, 3, 4 और 5 से कम बार रोल किया जाएगा। हालांकि, अंतर मूल रूप से महत्वहीन है।
एक श्रेणी के साथ यादृच्छिक पूर्णांक के लिए, प्रयास करें:
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 / जावास्क्रिप्ट को एक फ़ाइल में सहेजें और एक ब्राउज़र के साथ खोलें। एक मिलियन फ़ंक्शन कॉल के वितरण को दर्शाने वाला कोड एक ग्राफ का उत्पादन करेगा । कोड किनारे के मामलों को भी रिकॉर्ड करेगा, इसलिए यदि फ़ंक्शन अधिकतम से अधिक मूल्य का उत्पादन करता है, या न्यूनतम से कम है, तो आप .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"> [' + (i + min - 1) + ']: '+array[i]+'</span> ');
}
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;
}मुझे पता है कि यह सवाल पहले से ही उत्तर में है लेकिन मेरा जवाब किसी की मदद कर सकता है
मुझे W3Schools पर यह सरल विधि मिली:
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
highकि केवल एक बार उपयोग किया जाता है, आप high-low+1अलग-अलग वेतन वृद्धि कथन के बजाय उपयोग कर सकते हैं । साथ ही, अधिकांश उपयोगकर्ता lowपैरामीटर के पहले आने की उम्मीद करेंगे ।
<!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 () का उपयोग किए बिना किसी भी निर्दिष्ट लंबाई की एक यादृच्छिक संख्या उत्पन्न कर सकता है :
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);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यदि आपको एक बड़ी रेंज की आवश्यकता है, तो इसका उपयोग करने के लिए संशोधित किया जा सकता है ।) चुने हुए रेंज के बावजूद, अस्वीकार किए गए उत्पन्न मानों का अंश हमेशा 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]क्रिप्टो-मजबूत यादृच्छिक पूर्णांक संख्या को ragne [x, y] में लाने के लिए प्रयास करें
let cs= (x,y)=>x+(y-x+1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32|0
console.log(cs(4,8))आप यह कोड स्निपेट कर सकते हैं,
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;
}do - whileबजाय का उपयोग करेंwhile
Ionuon G. Stan ने एक बेहतरीन उत्तर लिखा लेकिन यह मेरे लिए समझ से थोड़ा जटिल था। तो, मुझे जेसन एनेलो द्वारा https://teamtreehouse.com/community/mathfloor-mathrandom-max-min-1-min-explanation पर समान अवधारणाओं की एक सरल व्याख्या मिली ।
नोट: जेसन के स्पष्टीकरण को पढ़ने से पहले आपको केवल एक महत्वपूर्ण बात पता होनी चाहिए "ट्रंकट" की एक परिभाषा है। वर्णन करते समय वह उस शब्द का उपयोग करता है Math.floor()। ऑक्सफोर्ड डिक्शनरी "ट्रंकट" को परिभाषित करती है:
ऊपर या सिरे को काटकर छोटा करना (कुछ)।
यह 20 अंकों के यूनीक्वाय रैंडम नंबर तक जनरेट कर सकता है
जे एस
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);
/ * एक फ़ंक्शन लिखें जो 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;
};मैंने यह फ़ंक्शन बनाया जो न्यूनतम, अधिकतम, बहिष्कृत (बाहर करने के लिए ints की एक सूची), और बीज (यदि आप एक वरीयता प्राप्त यादृच्छिक जनरेटर चाहते हैं) जैसे खाते विकल्पों में लेता है।
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]Gist: https://gist.github.com/madprops/757deb000bdec25776d5036dae58ee6e
Math.floor निकटतम पूर्णांक के एक नंबर को गोल करता है
function generateRandomInteger (min, max) {
return Math.floor(random(min,max))
}`तो 4 और 8 समावेशी के बीच एक यादृच्छिक पूर्णांक बनाने के लिए, निम्नलिखित फ़ंक्शन को निम्नलिखित तर्कों के साथ कॉल करें:
generateRandomInteger (4,9)0 और n के बीच रैंडम नंबर जनरेट करने का मेरा तरीका, जहाँ n <= 10 (n बाहर रखा गया है):
Math.floor((Math.random() * 10) % n)