Atsitiktinių sveikųjų skaičių generavimas javascript tam tikrame diapazone?

Kaip galiu generuoti atsitiktinį sveikąjį skaičių tarp dviejų nustatytų kintamųjų, pvz., „Javascript“. x = 4 ir y = 8 rodo bet kurį iš 4, 5, 6, 7, 8?

1594
06 окт. nustatė zacharyliu 06 okt. 2009-10-06 23:05 '09, 11:05 val. 2009-10-06 23:05
@ 26 atsakymai

Mozilla“ kūrėjo tinklo puslapyje yra keletas pavyzdžių:

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

Čia yra logika. Tai paprasta trijų taisyklių taisyklė:

Math.random() grąžina Number nuo 0 (imtinai) iki 1 (išimtis). Taigi, mes turime šį intervalą:

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

Dabar norėtume, kad numeris nuo min (imtinai) iki max

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

Mes galime naudoti Math.random kad gautume korespondentą intervale [min, max]. Tačiau, pirma, turime šiek tiek susiaurinti problemą atimdami min Nuo antrojo intervalo:

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

Ji suteikia:

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

Dabar mes galime taikyti Math.random ir tada apskaičiuoti korespondentą. Leiskite pasirinkti atsitiktinį skaičių:

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

Taigi, norėdami rasti x , mes padarytume:

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

Nepamirškite pridėti min atgal, kad gautume skaičių intervale [min, max]:

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

Tai buvo pirmoji MDN funkcija. Antrasis grąžina sveikąjį skaičių nuo min iki max .

Dabar galite naudoti round , ceil ar floor kad gautumėte sveikų skaičių.

Galite naudoti Math.round(Math.random() * (max - min)) + min , tačiau tai suteikia netolygų pasiskirstymą. Ir min ir max turi tik pusę galimybės mesti:

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

Kadangi max neįtrauktas į intervalą, jis turi dar mažesnes galimybes mesti nei min .

Su Math.floor(Math.random() * (max - min +1)) + min jūs gaunate puikiai tolygų pasiskirstymą.

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

Šioje lygtyje negalite naudoti „ ceil() ir -1 , nes dabar max mažesnė tikimybė mesti, bet jūs taip pat galite mesti (nepageidaujamą) min-1 .

3247
06 окт. atsakymas į Ionuț G. Stan 06 spalis 2009-10-06 23:08 '09 23:08 2009-10-06 23:08
 var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum; 
border=0
474
06 окт. atsakymą pateikė Darin Dimitrov 06 spalis 2009-10-06 23:09 '09 at 23:09 PM 2009-10-06 23:09

Math.random ()

Mozilla“ kūrėjo tinklo dokumentuose:

 // Returns a random integer between min (include) and max (include) Math.floor(Math.random() * (max - min + 1)) + min; 

Naudingi pavyzdžiai:

 // 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; 
86
25 марта '15 в 4:58 2015-03-25 04:58 Atsakymą pateikė „ Lior Elrom “ kovo 15 d. 15 val. 4:58 2015-03-25 04:58
 function getRandomizer(bottom, top) { return function() { return Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom; } } 

naudoti:

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

suskirstymas:

Grąžiname funkciją (skolinasi iš funkcinio programavimo), kuris, kai jis vadinamas, grąžina atsitiktinį sveikąjį skaičių tarp bottom ir top verčių, įskaitant. Mes sakome „imtinai“, nes norime įtraukti tiek apatinį, tiek viršutinį skaičių, kurį galima grąžinti. Taigi, getRandomizer( 1, 6 ) grąžins 1, 2, 3, 4, 5 arba 6.

(mažesnis mažesnis skaičius, viršutinis - didesnis skaičius)

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

Math.random() grąžina atsitiktinį dvynį tarp 0 ir 1, o jei padauginsime jį vienu pliusu tarp skirtumo tarp top ir bottom , mes gauname dvigubą vietą tarp 0 ir 1+ba .

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

Math.floor skaičių iki artimiausio sveikojo skaičiaus. Taigi dabar mes turime visus sveikus skaičius nuo 0 iki top-bottom . 1 atrodo painus, bet jis turėtų būti, nes mes visada apvaliame, todėl viršutinis skaičius niekada nebus pasiektas be jo. Sukurtas dešimtainis skaičius turi būti nuo 0 iki (1+top-bottom) , kad galėtume suapvalinti ir gauti int nuo diapazono nuo 0 iki top-bottom

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

Ankstesniame pavyzdyje pateiktas kodas davė mums sveiką skaičių intervale 0 ir top-bottom , todėl viskas, ką turime padaryti, yra pridėti bottom prie šio rezultato, kad gautume sveiką skaičių diapazono bottom ir top numeryje: D


PASTABA. Jei išlaikysite ne sveiko skaičiaus ar didesnį skaičių, gausite nepageidaujamą elgesį, tačiau jei kas nors to neprašys, aš neužsikreipsite į argumentų patikros kodą, nes tai yra gana toli nuo pradinio klausimo.

50
06 окт. Gordon Gustafson atsakymas, 06 spalis 2009-10-06 23:08 '09 23:08 2009-10-06 23:08
 function randomRange(min, max) { return ~~(Math.random() * (max - min + 1)) + min } 

Arba, jei naudojate „ Underscore.js“ , galite naudoti

 _.random(min, max) 
28
09 февр. Codler atsakė 09 Feb. 2013-02-09 22:51 '13, 10:51 val. 2013-02-09 22:51

Grąžina atsitiktinį skaičių nuo 1 iki 10:

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

Grąžina atsitiktinį skaičių nuo 1 iki 100:

 Math.floor((Math.random()*100) + 1) 
28
28 марта '14 в 14:31 2014-03-28 14:31 atsakymas pateikiamas Prasobh.K kovo 28 d. 14, 14:31 2014-03-28 14:31

Kiti atsakymai neatsižvelgia į gana pagrįstus 0 ir 1 parametrus. Vietoj to, vietoj round , naudokite „ ceil arba 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 
13
21 июля '14 в 19:42 2014-07-21 19:42 atsakymą pateikė „ Starkers“ liepos 21 d. 14:42 2014-07-21 19:42

Sukūrus atsitiktinį skaičių naudojant kompiuterinę programą, jis vis tiek laikomas atsitiktiniu numeriu, jei pasirinktas numeris yra originalus arba pilnas. Bet jei jis buvo pakeistas, matematikai nepriima to kaip atsitiktinio skaičiaus ir gali jį pavadinti šališku numeriu. Tačiau, jei kuriate paprastos užduoties programą, taip nebus. Tačiau, jei kuriate programą, skirtą sukurti atsitiktinį skaičių vertingos medžiagos, pvz., Loterijos programos ar lošimo žaidimo, tada jūsų programa bus atmesta vadovybei, jei neatsižvelgsite į šį atvejį.

Taigi, tiems žmonėms, čia yra mano pasiūlymas:

Sukurkite atsitiktinį skaičių naudojant Math.random() (tarkim, tai yra n )

 Now for [0,10) ==> n*10 (ie one digit) and for[10,100) ==> n*100 (ie 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. (ie get floor) - using Math.floor(), this can be done. 

Jei žinote, kaip skaityti atsitiktinių skaičių lentelę, kad pasirinktumėte atsitiktinį skaičių, žinote pirmiau minėtą procesą (dauginimas iš 1, 10, 100 ir tt) nepažeidžia to, ką minėjau pradžioje. (Kadangi ji keičia tik dešimtainio taško vietą.)

Ištirkite šį pavyzdį ir suprojektuokite jį pagal savo poreikius.

Jei jums reikalingas pavyzdys [0,9], tuomet jūsų atsakymas yra n * 10, o jei jums reikia [0.99], tada n * 100 yra jūsų atsakymas ir tt

Dabar įveskite savo vaidmenį:

Prašėte numerių tarp tam tikro intervalo. (Šiuo atveju jūs esate šališkas šioje srityje. - Priimdami skaičių iš [1.6], sukdami kubą, tapsite priklausomas nuo [1.6], tačiau jis vis dar yra atsitiktinis atvejis, jei ir tik tada, kai mirtis yra nešališka.)

Taigi, apsvarstykite savo intervalą ==> [78, 247] elementų skaičių intervale = 247 - 78 + 1 = 170; (kadangi abu sienos yra įtrauktos.

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

Pastaba Pirma, pirmuoju metodu sukūriau masyvą, kuriame yra reikalingi numeriai, ir atsitiktinai juos įterpia į kitą masyvą. Antruoju metodu atsitiktinai sugeneruokite numerius ir išbandykite juos reikiamame intervale. Tada įdėkite jį į masyvą. Čia aš sukūriau du atsitiktinius numerius ir panaudojau juos maksimaliai padidinti programos greitį, sumažinant gedimų skaičių, gaunant naudingą skaičių. Tačiau pridėjus sugeneruotų skaičių, taip pat bus šiek tiek šališkumo. Todėl rekomenduoju savo pirmąjį būdą sukurti atsitiktinius skaičius tam tikrame diapazone.

Abiem metodais jūsų konsolė parodys rezultatą. (Jei norite atidaryti konsolę, „Chrome“ paspauskite mygtuką f12)

10
10 февр. Atsakymą pateikė Janaka R Rajapaksha 10 vasaris. 2013-02-10 16:22 '13, 16:22, 2013-02-10 16:22

Atsitiktinis sveikasis skaičius su intervalu, pabandykite:

 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; } 
9
26 окт. atsakymas, kurį pateikė vartotojo1764199 spalis 26 2012-10-26 01:15 '12 ne 1:15 2012-10-26 01:15

Jei jums reikia kintamojo nuo 0 iki maks., Galite naudoti:

 Math.floor(Math.random() * max); 
9
02 окт. Stanislovo Vincento atsakymas 02 okt. 2017-10-02 11:30 '17, 11:30, 2017-10-02 11:30

Štai MS DotNet Įtraukti Random klasę į javascript -

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

Taikymas:

  var r = new Random(); var nextInt = r.Next(1, 100); //returns an integer between range var nextDbl = r.NextDouble(); //returns a random decimal 
9
15 нояб. atsakymą pateikė Ariful Islam 15 Nov. 2016-11-15 08:38 '16 at 8:38 am 2016-11-15 08:38

Naudojant šį kodą, galite generuoti atsitiktinių skaičių masyvą, pakartodami tam tikrą intervalą.

 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. ie 4 // max(inclusive) : maximun value of a range. it must be any positive integer. ie 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; } 
7
19 авг. atsakymas suteikiamas Yusuf 19 rug. 2015-08-19 19:43 '15, 19:43, 2015-08-19 19:43

Norėdami gauti atsitiktinį skaičių, pvz., Nuo 1 iki 6, pirmą kartą paleiskite:

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

Taip atsitiktinis skaičius padauginamas iš 6 ir į jį įtraukiamas 0,5. Tada surinkite skaičių iki teigiamo sveikojo skaičiaus:

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

Tai suapvalina skaičių iki artimiausio sveikojo skaičiaus.

Arba, jei norite geriau suprasti, atlikite šiuos veiksmus:

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

Paprastai šio kodo kodas yra kintamieji:

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

Priežastis, kodėl atimama 0,5 iš minimalios vertės, yra ta, kad naudojant tik minimalią vertę galėsite gauti sveikąjį skaičių, kuris būtų didesnis už maksimalią vertę. Pašalinus 0,5 iš minimalios vertės, iš esmės neleidžiate apvalinti didžiausios vertės.

Tikiuosi, kad tai padės.

7
22 июля '13 в 8:56 2013-07-22 08:56 atsakymą pateikė „ Learner.js “ liepos 13 d. 13:56 2013-07-22 08:56

Atsitiktinis sveikasis skaičius tarp mažiausių ir didžiausių:

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

Ne labiausiai elegantiškas sprendimas. Bet kažkas greitai.

6
30 сент. Atsakymas pateikiamas brooklynsweb rugsėjo 30 d 2013-09-30 03:44 '13, 03:44 2013-09-30 03:44

Žinau, kad į šį klausimą jau buvo atsakyta, bet mano atsakymas gali padėti kam nors.

W3Schools rado šį paprastą metodą:

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

Tikiuosi, kad tai padės kam nors.

6
24 апр. PeMaCN atsakymas, pateiktas balandžio 24 d 2016-04-24 18:51 '16 at 18:51 PM 2016-04-24 18:51

Čia naudoju atsitiktinių skaičių generavimui.

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

Mes atliekame high++ nes Math.random() generuoja atsitiktinį skaičių nuo 0 iki (imtinai) ir 1 (išimtis). Neįtraukta reiškia, kad mes turime didinti ne daugiau kaip vieną, prieš atlikdami bet kokį matematiką. Tada mes atimame mažąją vertę iš maksimalios, suteikdami mums didžiausią skaičių generuoti - žemą, tada + žemą, kuri grįžta į normalią būseną ir mažiausias skaičius mažiausiai. tada grąžiname gautą skaičių

random(7,3) gali grąžinti 3,4,5,6, or 7

5
04 янв. Atsakymas, kurį pateikė Travis Jan 04 2015-01-04 06:39 '15 at 6:39 2015-01-04 06:39
  <!DOCTYPE html> <html> <head> <meta charset="utf-8" /> </head> <body> <script>  var array = new Uint8Array(2); window.crypto.getRandomValues(array); console.log(array[0] + array[1]); </script> </body> </html> 

„Uint8Array“ sukuria masyvą, užpildytą iki trijų skaitmenų, o tai turėtų būti ne daugiau kaip 999. Šis kodas yra labai trumpas.

4
13 дек. Atsakymas duotas laimingam 13 d. 2015-12-13 02:47 '15 at 2:47 2015-12-13 02:47
 function rnd(min,max){ return Math.floor(Math.random()*(max-min+1)+min ); } 
3
16 авг. atsakymą pateikė Aylian Craspa 16 rug . 2018-08-16 07:42 '18, 7:42 ; 2018-16 07:42
 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))); } 

Norėdami išbandyti šią funkciją ir šios funkcijos variantus, išsaugokite toliau pateiktą HTML / JavaScript failą ir atidarykite jį naršyklėje. Kodas parodys grafiką, rodantį vieno milijono funkcijų skambučių pasiskirstymą. Kodas taip pat įrašys kraštinius atvejus, taigi, jei funkcija sukuria didesnę nei maksimalią arba mažesnę nei min. Reikšmę, jūs .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) + ']: } document.write('<hr/>'); </script> </head> <body> </body> </html> 
3
06 окт. Atsakyti Chris 06 spalis 2009-10-06 23:09 '09 at 23:09 PM 2009-10-06 23:09

Tai yra mano pasirinktas atsitiktinis skaičius diapazone, nes norėjau gauti atsitiktinį skaičių intervale nuo bazės iki eksponento. pavyzdžiui, bazė = 10, eksponentas = 2, suteikia atsitiktinį skaičių nuo 0 iki 100, idealiai ir tt

jei jis padeda jį naudoti, čia jis yra:

 // 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); 
3
07 окт. Goran B. atsakymas . Spalio 07 d. 2015-10-07 08:05 '15, 08:05 2015-10-07 08:05

Čia pateikiamas „JavaScript“ funkcijos pavyzdys, galintis generuoti bet kurio nurodyto ilgio atsitiktinį skaičių nenaudojant „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; } 
3
14 авг. Nilesh Pawar atsakymas 14 rug. 2017-08-14 10:15 '17 10:15 am 2017-08-14 10:15

/ * Parašykite funkciją, pavadintą randUpTo kuris užima skaičių ir grąžina atsitiktinį sveikąjį skaičių nuo 0 iki to numerio? * /

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

/ * Parašykite funkciją, pavadintą „ randBetween kuri užima du numerius, atitinkančius diapazoną, ir grąžina atsitiktinį skaičių tarp šių dviejų numerių. * /

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

/ * Parašykite funkciją, pavadintą „ randFromTill kuri užima du numerius, randFromTill intervalą, ir grąžina atsitiktinį skaičių tarp min (imtinai) ir maks. * /

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

/ * Parašykite funkciją, pavadintą randFromTo kuris užima du numerius, atitinkančius intervalą, ir grąžina atsitiktinį sveikąjį skaičių nuo min (imtinai) iki maks. (Imtinai) * /

 var randFromTo = function (min, max) { return Math.floor(Math.random() * (max - min + 1)) + min; }; 
0
08 июня '18 в 9:09 2018-06-08 09:09 atsakymą pristato Prakhar Mittal birželio 18 d., 09: 09-09-08 09:09

Jis gali apdoroti iki 20 skaitmenų unikalių atsitiktinių skaičių

Js

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

2019

27 апр. atsakymas pateikiamas Nofi 27 d. 2016-04-27 15:07 '16 at 15:07 2016-04-27 15:07

Sukurkite atsitiktinį penkių skaitmenų skaičių

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

pavyzdys

  rn(2342, 9999) 

Viltis padės

0
15 дек. Atsakymas pateikiamas Oladimeji Ajeniya gruodžio 15 d. 2018-12-15 01:20 '18 prie 1:20 2018-12-15 01:20

Įdomu, koks pasiskirstymas būtų po pakankamo skaičiaus tokių atsitiktinės atrankos funkcijos funkcijų.

Taip pat patikrinkite, ar skirtingose ​​naršyklėse šis paskirstymas bus daugiau ar mažiau toks pat.

Taigi čia pateikiamas fragmentas. Skaičius galima keisti prieš paspaudžiant mygtuką.

 <div id="topContainer"> <div id="inputAndButton" style="float: left;"> <p>Min : <input type="number" id="randomMinLimit" value=4></p> <p>Max : <input type="number" id="randomMaxLimit" value=8></p> <p>Loops: <input type="number" id="loopLimit" value=1000></p> <button type="button" onclick="loopRandomAndPrint()"> Loop random function and show </button> </div> <div id="tableContainer" style="float: right;"> </div> </div> 
-1
11 июля '18 в 20:24 2018-07-11 20:24 atsakymas pateikiamas LukStorms liepos 11 d. 18 val. 20:24 2018-07-11 20:24

Alternatyvus sprendimas: -

 let makeGuess = function(guess){ let min = 1; let max = 5; let randomNumber = Math.floor(Math.random() * (max - min + 1)) + min return guess === randomNumber; } console.log(makeGuess(1)); 
-1
02 июля '18 в 9:31 2018-07-02 09:31 atsakymas duotas bajranui liepos 2 d., 18 val. 9:31. 2018-07-02 09:31