Bagaimana saya dapat menghasilkan bilangan acak antara dua ditentukan variabel-variabel dalam JavaScript, misal x = 4
dan y = 8
akan output dari setiap4, 5, 6, 7, 8
?
Ada beberapa contoh di Mozilla Developer Network halaman:
/**
* 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;
}
Berikut ini's logika di balik itu. It's sederhana aturan tiga:
Matematika.random()
mengembalikan Nomor
antara 0 (inklusif) dan 1 (eksklusif). Jadi kita memiliki interval seperti ini:
[0 .................................... 1)
Sekarang, kita'd seperti nomor antara min
(inklusif) dan max
(exclusive):
[0 .................................... 1)
[min .................................. max)
Kita dapat menggunakan Matematika.randomuntuk mendapatkan koresponden di [min, max) interval. Tetapi, pertama kita harus factor sedikit masalah dengan mengurangkan
min` dari interval kedua:
[0 .................................... 1)
[min - min ............................ max - min)
Hal ini memberikan:
[0 .................................... 1)
[0 .................................... max - min)
Kita sekarang dapat menerapkan Matematika.random` dan kemudian menghitung koresponden. Let's memilih nomor acak:
Math.random()
|
[0 .................................... 1)
[0 .................................... max - min)
|
x (what we need)
Jadi, dalam rangka untuk menemukan x
, akan kami lakukan:
x = Math.random() * (max - min);
Don't lupa untuk menambahkan min
kembali, sehingga kita mendapatkan nomor dalam [min, max) interval:
x = Math.random() * (max - min) + min;
Yang pertama adalah fungsi dari MDN. Yang kedua, mengembalikan sebuah integer antara min
dan max
, kedua inklusif.
Sekarang untuk mendapatkan bilangan bulat, anda bisa menggunakan bulat
, l
atau lantai
.
Anda bisa menggunakan Matematika.round(Math.random() * (max - min)) + min
, namun ini memberikan non-bahkan distribusi. Kedua, min
dan max
hanya memiliki sekitar setengah kesempatan untuk roll:
min...min+0.5...min+1...min+1.5 ... max-0.5....max
└───┬───┘└────────┬───────┘└───── ... ─────┘└───┬──┘ ← Math.round()
min min+1 max
Dengan max
dikecualikan dari interval, ia memiliki kesempatan bahkan kurang untuk roll dari min
.
Dengan Matematika.floor(Math.random() * (max - min +1)) + min` anda memiliki sempurna bahkan distribusi.
min.... min+1... min+2 ... max-1... max.... max+1 (is excluded from interval)
| | | | | |
└───┬───┘└───┬───┘└─── ... ┘└───┬───┘└───┬───┘ ← Math.floor()
min min+1 max-1 max
Anda dapat't menggunakan ceil()
dan -1
dalam persamaan itu karena max
sekarang memiliki lebih sedikit kesempatan untuk roll, tapi anda dapat roll (yang tidak diinginkan) min-1
hasilnya juga.
Dari Mozilla Pengembang Jaringan dokumentasi:
// Returns a random integer between min (include) and max (include)
Math.floor(Math.random() * (max - min + 1)) + min;
Berguna contoh:
// 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;
function getRandomizer(bottom, top) {
return function() {
return Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom;
}
}
penggunaan:
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.
}
rincian:
Kami adalah mengembalikan fungsi (pinjaman dari pemrograman fungsional) yang bila disebut, akan mengembalikan bilangan bulat acak antara nilai-nilai bawah
dan top
, inklusif. Kita katakan 'inklusif' karena kita ingin memasukkan kedua bagian bawah dan atas di kisaran angka yang dapat dikembalikan. Dengan cara ini, getRandomizer( 1, 6 )
akan kembali baik 1, 2, 3, 4, 5, atau 6.
(bawah adalah angka yang lebih rendah, atas jumlah yang lebih besar)
Math.random() * ( 1 + top - bottom )
Matematika.random()
mengembalikan acak ganda antara 0 dan 1, dan jika kita kalikan dengan satu ditambah perbedaan antara atas
dan bawah
, we'll mendapatkan double di suatu tempat antara 0
dan 1+b-a
.
Math.floor( Math.random() * ( 1 + top - bottom ) )
Matematika.lantai
putaran angka ke bawah ke bilangan bulat terdekat. Jadi kita sekarang memiliki semua bilangan bulat antara 0
dan atas-bawah
. 1 terlihat membingungkan, tapi itu perlu ada karena kita selalu pembulatan ke bawah, sehingga bagian atas akan pernah benar-benar dapat dicapai tanpa itu. Random desimal yang kita hasilkan harus dalam range 0
ke (1+atas-bawah)
sehingga kita dapat putaran bawah dan mendapatkan int di kisaran 0
ke atas-bawah
Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom
Kode pada contoh sebelumnya memberi kami integer dalam range 0
dan atas-bawah
, sehingga semua yang perlu kita lakukan sekarang adalah menambahkan bawah
yang hasilnya untuk mendapatkan integer dalam range bawah
dan top
inklusif. :D
CATATAN: Jika anda lulus dalam non-integer nilai atau jumlah yang lebih besar pertama anda'll mendapatkan perilaku yang tidak diinginkan, tetapi jika ada permintaan itu saya tidak akan menyelidiki argumen memeriksa kode yang agak jauh dari maksud dari pertanyaan awal.
Kembali nomor acak antara 1 dan 10:
Math.floor((Math.random()*10) + 1);
Kembali nomor acak antara 1 dan 100:
Math.floor((Math.random()*100) + 1)
function randomRange(min, max) {
return ~~(Math.random() * (max - min + 1)) + min
}
Alternatif jika anda menggunakan Underscore.js anda dapat menggunakan
_.random(min, max)
Jika anda membutuhkan variabel antara 0 dan max yang dapat anda gunakan:
Math.floor(Math.random() * max);
Lain jawaban don't account untuk sangat wajar parameter 0
dan 1
. Sebaliknya anda harus menggunakan bulat
bukan dari l
atau lantai
:
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
Berikut ini adalah MS DotNet Pelaksanaan Random class di 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;
}());
Penggunaan:
var r = new Random();
var nextInt = r.Next(1, 100); //returns an integer between range
var nextDbl = r.NextDouble(); //returns a random decimal
Gunakan fungsi ini untuk mendapatkan angka acak antara yang diberikan berkisar
function rnd(min,max){
return Math.floor(Math.random()*(max-min+1)+min );
}
Setelah menghasilkan nomor acak dengan menggunakan program komputer, hal ini masih dianggap sebagai nomor acak jika memilih nomor merupakan bagian atau salah satu dari yang awal. Tapi jika itu berubah, maka matematika tidak menerima itu sebagai sebuah nomor acak dan mereka dapat menyebutnya bias nomor. Tetapi jika anda sedang mengembangkan sebuah program untuk tugas sederhana, ini tidak akan menjadi kasus untuk dipertimbangkan. Tetapi jika anda sedang mengembangkan sebuah program untuk menghasilkan nomor acak untuk barang-barang berharga seperti program undian, atau permainan judi, maka program anda akan ditolak oleh manajemen jika anda tidak mempertimbangkan tentang kasus di atas.
Jadi untuk orang-orang semacam orang, di sini adalah saran saya:
Menghasilkan nomor acak dengan menggunakan Matematika.random().(katakanlah ini
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.
Jika anda tahu cara membaca tabel nomor acak memilih nomor acak, anda tahu proses di atas(mengalikannya dengan 1, 10, 100 dan seterusnya) tidak melanggar salah satu yang saya sebutkan di awal.( Karena perubahan hanya untuk tempat titik desimal.)
Mempelajari contoh berikut dan mengembangkannya untuk kebutuhan anda.
Jika anda membutuhkan sampel [0,9] kemudian lantai n10 adalah jawaban anda dan jika perlu [0,99] kemudian lantai n100 adalah jawaban anda dan sebagainya.
Sekarang mari masuk ke peran anda:
Anda've meminta angka di antara rentang tertentu. (Dalam hal ini anda bias antara kisaran tersebut. - Dengan mengambil jumlah dari [1,6] dengan gulungan mati, maka anda bias ke [1,6] tapi masih acak jika dan hanya jika mati tidak bias.)
Jadi pertimbangkan range ==> [78, 247] jumlah elemen dari berbagai = 247 - 78 + 1 = 170; (karena kedua batas-batas yang inklusif.
/*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);
Catatan: Dalam metode ini, pertama saya membuat sebuah array yang berisi angka-angka yang anda butuhkan dan kemudian secara acak menempatkan mereka ke dalam array lain. Dalam dua metode, menghasilkan angka acak dan memeriksa orang-orang yang berada di kisaran yang anda butuhkan. Kemudian memasukkannya ke dalam array. Di sini saya menghasilkan dua angka acak dan digunakan total mereka untuk memaksimalkan kecepatan program dengan meminimalkan tingkat kegagalan yang memperoleh berguna jumlah. Namun menambahkan angka yang dihasilkan juga akan memberikan beberapa biassness. Jadi saya akan merekomendasikan saya pertama metode untuk menghasilkan angka acak dalam kisaran tertentu.
Dalam kedua metode, konsol anda akan lihat hasilnya.(Tekan f12 di Chrome untuk membuka konsol)
Untuk sembarang bilangan bulat dengan jangkauan, cobalah:
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;
}
Untuk mendapatkan nomor acak yang mengatakan antara 1 dan 6, pertama lakukan:
0.5 + (Math.random() * ((6 - 1) + 1))
Ini mengalikan nomor acak oleh 6 dan kemudian menambahkan 0,5 itu. Putaran berikutnya jumlah bilangan bulat positif dengan melakukan:
Math.round(0.5 + (Math.random() * ((6 - 1) + 1))
Putaran ini jumlah ke seluruh nomor terdekat.
Atau untuk membuatnya lebih mudah dimengerti melakukan hal ini:
var value = 0.5 + (Math.random() * ((6 - 1) + 1))
var roll = Math.round(value);
return roll;
Secara umum kode untuk melakukan hal ini menggunakan variabel adalah:
var value = (Min - 0.5) + (Math.random() * ((Max - Min) + 1))
var roll = Math.round(value);
return roll;
Alasan untuk mengambil 0.5 dari nilai minimum adalah karena menggunakan nilai minimum saja akan memungkinkan anda untuk mendapatkan sebuah bilangan bulat yang merupakan salah satu lebih dari nilai maksimum. Dengan mengambil 0.5 dari nilai minimum anda pada dasarnya mencegah nilai maksimum dari yang dibulatkan.
Harapan yang membantu.
Menggunakan kode berikut anda dapat menghasilkan array dari angka acak, tanpa mengulang, dalam rentang tertentu.
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;
}
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)));
}
Untuk menguji fungsi ini, dan variasi dari fungsi ini, simpan kode di bawah ini di HTML/JavaScript ke file dan buka dengan browser. Kode tersebut akan menghasilkan grafik menunjukkan distribusi dari satu juta panggilan fungsi. Kode juga akan merekam edge kasus-kasus, sehingga jika fungsi menghasilkan nilai lebih besar dari maks, atau kurang dari satu menit, anda.akan.tahu.tentang.itu.
<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>
Random seluruh jumlah antara terendah dan tertinggi:
function randomRange(l,h){
var range = (h-l);
var random = Math.floor(Math.random()*range);
if (random === 0){random+=1;}
return l+random;
}
Bukan solusi yang paling elegan.. tapi sesuatu yang cepat.
Berikut ini's apa yang saya gunakan untuk menghasilkan angka acak.
function random(high,low) {
high++;
return Math.floor((Math.random())*(high-low))+low;
}
Kita lakukan mengeksekusi tinggi ++
karenaMatematika.random()
menghasilkan nomor acak antara 0, (inklusif), dan 1(eksklusif) salah satu Yang dikecualikan, artinya kita harus meningkatkan tinggi per satu sebelum mengeksekusi matematika. Kami kemudian kurangi rendah dari tinggi, memberikan jumlah tertinggi untuk menghasilkan rendah, maka +rendah, tinggi membawa kembali normal, dan membuat jumlah terendah minimal rendah. kemudian kita kembali jumlah yang dihasilkan
random(7,3)
bisa kembali 3,4,5,6, atau 7
Berikut adalah contoh dari sebuah fungsi javascript yang dapat menghasilkan nomor acak dari setiap panjang tertentu tanpa menggunakan Matematika.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;
}
<!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 membuat array diisi dengan jumlah hingga 3 digit yang akan menjadi maksimal 999. Kode ini sangat pendek.