Pembangkit bilangan acak dalam JavaScript dalam rentang tertentu?

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?

thadeuszlay
Pertanyaan edit 11 Maret 2019 в 1:34
Pemrograman
javascript random integer
6 Oktober 2009 в 8:05
83 tayangan
Mengomentari pertanyaan (3)
Larutan

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 mengurangkanmin` 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.

micnic
Jawaban edit 13 April 2019 в 9:01
Komentar (29)
 
var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
Komentar (5)

Matematika.random()

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;
Lior Elrom
Jawaban edit 6 Juni 2018 в 2:16
Komentar (0)
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
Komentar (7)

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)
nbro
Jawaban edit 26 November 2015 в 10:13
Komentar (3)
function randomRange(min, max) {
  return ~~(Math.random() * (max - min + 1)) + min
}

Alternatif jika anda menggunakan Underscore.js anda dapat menggunakan

_.random(min, max)
Komentar (3)

Jika anda membutuhkan variabel antara 0 dan max yang dapat anda gunakan:

Math.floor(Math.random() *  max);
isherwood
Jawaban edit 7 Agustus 2018 в 4:22
Komentar (2)

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
Komentar (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
Komentar (1)

Gunakan fungsi ini untuk mendapatkan angka acak antara yang diberikan berkisar

function rnd(min,max){
    return Math.floor(Math.random()*(max-min+1)+min );
}
Aylian Craspa
Jawaban edit 30 Mei 2019 в 7:14
Komentar (0)

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 inin`)

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
Komentar (4)

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

Aku tahu pertanyaan ini sudah dijawab tapi jawaban saya bisa membantu seseorang.

Saya menemukan metode sederhana ini di W3Schools:

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

Berharap ini akan membantu seseorang.

Komentar (3)

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.

Komentar (1)

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




        <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
Komentar (0)

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.

Komentar (0)

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

Komentar (1)

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
Nilesh Pawar
Jawaban edit 14 Juni 2019 в 10:46
Komentar (3)



            <meta charset="utf-8" />


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

Uint8Array membuat array diisi dengan jumlah hingga 3 digit yang akan menjadi maksimal 999. Kode ini sangat pendek.

Komentar (0)