Tạo số nguyên ngẫu nhiên trong JavaScript trong một phạm vi cụ thể?


1955

Làm cách nào tôi có thể tạo số nguyên ngẫu nhiên giữa hai biến được chỉ định trong JavaScript, ví dụ x = 4y = 8sẽ xuất bất kỳ số 4, 5, 6, 7, 8nào?


1
đây là một ý chính hữu ích: gist.github.com/kerimdzhanov/7529623
Dan KK

9
Một lưu ý phụ: đối với những người sử dụng npm và đang tìm kiếm một giải pháp nhanh chóng, đáng tin cậy và sẵn sàng, có lodash.random có thể dễ dàng yêu cầu với một dấu chân siêu nhỏ (nó sẽ chỉ nhập phương thức chứ không phải toàn bộ lodash).
Nobita

nếu nó cần được bảo mật bằng tiền điện tử của nhà phát
hạnh phúc

Câu trả lời:


3834

Có một số ví dụ trên trang Mozilla Developer Network :

/**
 * 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;
}

Đây là logic đằng sau nó. Đó là một quy tắc đơn giản của ba:

Math.random()trả về Numbertừ 0 (đã bao gồm) và 1 (độc quyền). Vì vậy, chúng tôi có một khoảng như thế này:

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

Bây giờ, chúng tôi muốn một số giữa min(bao gồm) và max(độc quyền):

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

Chúng ta có thể sử dụng Math.randomđể lấy phóng viên trong khoảng [tối thiểu, tối đa). Nhưng, trước tiên chúng ta nên tính một chút vấn đề bằng cách trừ đi minkhoảng thứ hai:

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

Điều này mang lại:

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

Bây giờ chúng tôi có thể áp dụng Math.randomvà sau đó tính toán các phóng viên. Hãy chọn một số ngẫu nhiên:

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

Vì vậy, để tìm x, chúng tôi sẽ làm:

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

Đừng quên thêm minlại, để chúng tôi nhận được một số trong khoảng [tối thiểu, tối đa):

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

Đó là chức năng đầu tiên từ MDN. Cái thứ hai, trả về một số nguyên giữa minmax, bao gồm cả.

Bây giờ để có được số nguyên, bạn có thể sử dụng round, ceilhoặc floor.

Bạn có thể sử dụng Math.round(Math.random() * (max - min)) + min, tuy nhiên điều này mang lại sự phân phối không đồng đều. Cả hai minmaxchỉ có khoảng một nửa cơ hội để lăn:

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

Với maxloại trừ khỏi khoảng, nó thậm chí còn ít cơ hội để lăn hơn min.

Với Math.floor(Math.random() * (max - min +1)) + minbạn có một phân phối thậm chí hoàn hảo.

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

Bạn không thể sử dụng ceil()-1trong phương trình đó vì maxbây giờ có ít cơ hội hơn để cuộn, nhưng bạn cũng có thể cuộn min-1kết quả (không mong muốn) .


10
Nó chỉ làm điều đó bởi vì nó đang gọi floor, mà làm tròn xuống.
Josh Stodola

4
@ thezachperson31 Bạn có thể sử dụng round, nhưng sau đó cả hai, minmaxchỉ có một nửa cơ hội để lăn như những con số khác làm. Bạn cũng có thể trừ một và lấy ceil. Tuy nhiên, điều này khiến maxsố có ít cơ hội lăn hơn do [0,1)Khoảng thời gian.
Christoph

12
Tôi đã tạo một JSFiddle nếu có ai muốn kiểm tra phân phối của phương thức này: jsfiddle.net/F9UTG/1
ahren

8
@JackFrost vâng, đúng vậy. Bạn không ngu ngốc, bạn chỉ đang học thôi :)
Ionuț G. Stan

3
Câu hỏi này đã cũ, nhưng việc hiểu câu trả lời này đã khiến tôi mất quá nhiều thời gian Oo, tôi nghĩ việc mở rộng math.random trên phiên bản JavaScript tiếp theo sẽ hữu ích
Jonathan Ortega

527
var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;

19
Tôi biết đây là một câu trả lời RẤT cũ, nhưng sử dụng (Math.random() * (maximum - minimum + 1) ) << 0nhanh hơn.
Ismael Miguel

11
@IsmaelMiguel Sử dụng toán tử nhị phân ( x << 0, x | 0, ~~x) thay vì Math.floor()cải xthành hai bổ sung với phạm vi nhỏ hơn nhiều so với Number.MAX_SAFE_INTEGER(2³²⁻¹ vs 2⁵³), do đó bạn phải sử dụng nó một cách thận trọng!
le_m

@IsmaelMiguel Yo Tôi vừa thử phương pháp của bạn trong bảng điều khiển và ngẫu nhiên có giá trị âm! Math.randRange = (tối thiểu, tối đa) => (Math.random () * (tối đa - tối thiểu + 1)) << 0 Math.randRange (2.657348096152) -1407373159
bluejayke 13/2/19

@bluejayke Vì 657348096152 (1001100100001100111111111111000010011000 ở dạng nhị phân) có 40 bit, trong khi các nhà khoa học bitwise sử dụng 32 bit. Nếu bạn 657348096152|0có 218099864 (110011111111111111000010011000 ở dạng nhị phân).
Ismael Miguel

1
Đây là một câu trả lời thông minh. Làm cho phạm vi bên trong [min, max + 1) thực sự đạt được kết quả mong muốn của [min, max] được bao gồm cả. Cảm ơn bạn! :)
Mladen B.

135

Toán.random ()

Trả về một số ngẫu nhiên số nguyên giữa min ( bao gồm ) và max ( bao gồm ):

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

Hoặc bất kỳ số ngẫu nhiên nào giữa min ( bao gồm ) và max ( không bao gồm ):

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

Ví dụ hữu ích (số nguyên):

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

** Và luôn luôn tốt đẹp để được nhắc nhở (Mozilla):

Math.random () không cung cấp số ngẫu nhiên an toàn bằng mật mã. Không sử dụng chúng cho bất cứ điều gì liên quan đến an ninh. Thay vào đó, hãy sử dụng API Web Crypto và chính xác hơn là phương thức window.crypto.getRandomValues ​​().


56
function getRandomizer(bottom, top) {
    return function() {
        return Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom;
    }
}

sử dụng:

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

phá vỡ:

Chúng tôi đang trả về một hàm (mượn từ lập trình hàm) mà khi được gọi, sẽ trả về một số nguyên ngẫu nhiên giữa các giá trị bottomtop, bao gồm. Chúng tôi nói 'bao gồm' bởi vì chúng tôi muốn bao gồm cả đáy và đỉnh trong phạm vi số có thể được trả về. Bằng cách này, getRandomizer( 1, 6 )sẽ trả về 1, 2, 3, 4, 5 hoặc 6.

(dưới cùng là số thấp hơn, trên cùng là số lớn hơn)

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

Math.random()trả về một số ngẫu nhiên từ 0 đến 1 và nếu chúng ta nhân nó với một cộng với sự khác biệt giữa topbottom, chúng ta sẽ nhận được gấp đôi ở đâu đó giữa 01+b-a.

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

Math.floorlàm tròn số xuống số nguyên gần nhất. Vì vậy, bây giờ chúng ta có tất cả các số nguyên giữa 0top-bottom. Số 1 có vẻ khó hiểu, nhưng nó cần phải ở đó bởi vì chúng tôi luôn làm tròn xuống, vì vậy số lượng cao nhất sẽ không bao giờ thực sự đạt được nếu không có nó. Số thập phân ngẫu nhiên mà chúng tôi tạo cần phải nằm trong phạm vi 0để (1+top-bottom)chúng tôi có thể làm tròn xuống và lấy một số nguyên trong phạm vi 0đểtop-bottom

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

Mã trong ví dụ trước đã cho chúng tôi một số nguyên trong phạm vi 0top-bottomvì vậy, tất cả những gì chúng tôi cần làm bây giờ là thêm bottomvào kết quả đó để có được một số nguyên trong phạm vi bottomtopbao gồm. : D


LƯU Ý: Nếu bạn chuyển vào một giá trị không nguyên hoặc số lớn hơn trước tiên, bạn sẽ có hành vi không mong muốn, nhưng trừ khi có ai yêu cầu, tôi sẽ không đi sâu vào mã kiểm tra đối số vì nó khá xa so với mục đích của câu hỏi ban đầu .


1
Tôi nhận ra điều này là khoảng 2 năm rưỡi sau, nhưng với đầu vào 1 và 6, hàm của bạn trả về các giá trị 1,2,3,4 và 5, nhưng không bao giờ là 6, như thể nó đã được "bao gồm".
một số

9
@some, Nó có thể tồi tệ hơn, tôi 2 tuổi rưỡi + 1 ngày sau ^^
ajax333221

+1, tôi đã kiểm tra mã của bạn, nó xuất hiện để tạo ra một giá trị chính xác. Cấu trúc sáng tạo để xử lý các kịch bản cố định có thể được lặp lại rất nhiều trong mã.
Chris

Tại sao bạn có một chức năng trong một chức năng cho việc này?
Alph.Dev

1
@ Alph.Dev Để tách rời logic sử dụng trình tạo số ngẫu nhiên khỏi logic quyết định chính xác phân phối số ngẫu nhiên nào sẽ sử dụng. Khi mã sử dụng trình tạo số ngẫu nhiên chấp nhận nó làm tham số (hàm 0 đối số luôn trả về một số ngẫu nhiên mới), nó có thể hoạt động với bất kỳ loại trình tạo số ngẫu nhiên nào.
Gordon Gustafson

31
function randomRange(min, max) {
  return ~~(Math.random() * (max - min + 1)) + min
}

Thay thế nếu bạn đang sử dụng Underscore.js, bạn có thể sử dụng

_.random(min, max)

1
Underscore thực sự cung cấp một _.uniqueId()chức năng mà bạn có thể gọi cho các mô hình phía máy khách.
obfk

Sử dụng toán tử nhị phân ( x << 0, x | 0, ~~x) thay vì Math.floor()cải xthành hai bổ sung với phạm vi nhỏ hơn nhiều so với Number.MAX_SAFE_INTEGER(2³²⁻¹ vs 2⁵³), do đó bạn phải sử dụng nó một cách thận trọng!
le_m

31

Trả về một số ngẫu nhiên trong khoảng từ 1 đến 10:

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

Trả về một số ngẫu nhiên trong khoảng từ 1 đến 100:

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

"giữa" của bạn bao gồm hay độc quyền? tức là [1,10], [1,10), (1,10] hay (1,10)?
evandrix

1
Nó bao gồm một phần: [1, *)
Ivan Z

sự cần thiết của +1 ở cuối hàm là gì? Nó hoạt động hoàn hảo tôi đoán.
Shachi

18

Nếu bạn cần biến trong khoảng từ 0 đến tối đa, bạn có thể sử dụng:

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

Là bao gồm tối đa hoặc độc quyền>?
Cây

2
@Tree sử dụng Math.floor max là độc quyền. Nếu bạn muốn bao gồm tối đa, bạn có thể sử dụng Math.round.
Lu-ca

14

Các câu trả lời khác không chiếm các tham số hoàn toàn hợp lý của 01. Thay vào đó bạn nên sử dụng round thay vì của ceilhay 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

1
Câu trả lời của bạn là đúng nhưng tôi nghĩ ví dụ của bạn sai .. console.log(randomNumber(5,6)); # 9 6 6 5 7 79 & 7 có nằm trong khoảng từ 5 & 6 không? ...... bạn nên sửa hoặc giải thích ..
Sachin

12

Dưới đây là lớp triển khai MS DotNet của lớp Random trong 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;
}());

Sử dụng:

        var r = new Random();
        var nextInt = r.Next(1, 100); //returns an integer between range
        var nextDbl = r.NextDouble(); //returns a random decimal

Lớp MS DotNet Random thuộc giấy phép Ms-RSL , có nghĩa là nó có bản quyền. Vì vậy, hãy cẩn thận khi sử dụng mã phái sinh này, vì nó có thể tạo thành căn cứ cho các trường hợp vi phạm bản quyền.
JohannesB

12

Sử dụng hàm này để lấy số ngẫu nhiên giữa phạm vi đã cho

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

10

Sau khi tạo số ngẫu nhiên bằng chương trình máy tính, nó vẫn được coi là số ngẫu nhiên nếu số được chọn là một phần hoặc toàn bộ số ban đầu. Nhưng nếu nó được thay đổi, thì các nhà toán học không chấp nhận nó là một số ngẫu nhiên và họ có thể gọi nó là một số thiên vị. Nhưng nếu bạn đang phát triển một chương trình cho một nhiệm vụ đơn giản, đây sẽ không phải là trường hợp cần xem xét. Nhưng nếu bạn đang phát triển một chương trình để tạo một số ngẫu nhiên cho một thứ có giá trị như chương trình xổ số hoặc trò chơi đánh bạc, thì chương trình của bạn sẽ bị ban quản lý từ chối nếu bạn không xem xét về trường hợp trên.

Vì vậy, đối với những người như vậy, đây là gợi ý của tôi:

Tạo một số ngẫu nhiên bằng cách sử dụng Math.random(). (Nói điều này 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.

Nếu bạn biết cách đọc bảng số ngẫu nhiên để chọn một số ngẫu nhiên, bạn biết quy trình trên (nhân với 1, 10, 100, v.v.) không vi phạm bảng mà tôi đã đề cập ở đầu. (Vì nó chỉ thay đổi nơi của dấu thập phân.)

Nghiên cứu ví dụ sau và phát triển nó theo nhu cầu của bạn.

Nếu bạn cần một mẫu [0,9] thì tầng n * 10 là câu trả lời của bạn và nếu cần [0,99] thì tầng n * 100 là câu trả lời của bạn, v.v.

Bây giờ hãy nhập vai trò của bạn:

Bạn đã hỏi số trong phạm vi cụ thể. (Trong trường hợp này, bạn bị thiên vị trong phạm vi đó. - Bằng cách lấy một số từ [1,6] bằng cách lăn một cái chết, sau đó bạn bị thiên vị thành [1,6] nhưng vẫn là ngẫu nhiên nếu và chỉ khi chết không thiên vị .)

Vì vậy, hãy xem xét phạm vi của bạn ==> [78, 247] số phần tử của phạm vi = 247 - 78 + 1 = 170; (vì cả hai ranh giới được bao gồm.

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

Lưu ý: Trong phương thức một, đầu tiên tôi tạo một mảng chứa các số mà bạn cần và sau đó đặt chúng ngẫu nhiên vào một mảng khác. Trong phương pháp hai, tạo số ngẫu nhiên và kiểm tra những số đó nằm trong phạm vi mà bạn cần. Sau đó đặt nó vào một mảng. Ở đây tôi đã tạo ra hai số ngẫu nhiên và sử dụng tổng số chúng để tối đa hóa tốc độ của chương trình bằng cách giảm thiểu tỷ lệ thất bại có được một số hữu ích. Tuy nhiên, thêm số được tạo cũng sẽ cung cấp một số sinh khối. Vì vậy, tôi muốn giới thiệu phương pháp đầu tiên của mình để tạo các số ngẫu nhiên trong một phạm vi cụ thể.

Trong cả hai phương pháp, bảng điều khiển của bạn sẽ hiển thị kết quả. (Nhấn f12 trong Chrome để mở bảng điều khiển)


3
"Ngẫu nhiên" không nhất thiết có nghĩa là "phân phối đồng đều". "thiên vị" không ngụ ý "không ngẫu nhiên". phương tiện ngẫu nhiên rút ra từ một phân phối xác suất.
syzygy

6
Chỉ có thể nói những gì câu trả lời này đang cố gắng nói. Tuy nhiên, nếu bạn cần số ngẫu nhiên để sử dụng như số xổ số và đánh bạc. Đầu tiên bạn có thể không nên tạo chúng trên máy khách. Thứ hai, bạn cần một trình tạo số ngẫu nhiên an toàn bằng mật mã và thuật toán được cung cấp là không đủ. Gọi ngẫu nhiên nhiều lần không làm cho kết quả "ngẫu nhiên hơn". Tác giả dường như lo ngại về sự thiên vị, nhưng không cung cấp một thuật toán tốt để ngăn chặn nó. Trong thực tế, các câu trả lời ngắn khác được cung cấp tạo ra các số ngẫu nhiên không thiên vị (giả sử trình tạo ngẫu nhiên cơ bản là không thiên vị).
Jeff Walker Code Ranger

@JeffWalkerCodeRanger Tôi nghĩ điều anh ấy muốn nói là với thuật toán "bình thường" [tức là Math.floor(Math.random() * (6 - 1 + 1) + 1)] các số 1 và 6 sẽ nhất thiết phải được cuộn ít hơn 2, 3, 4 và 5. Tuy nhiên, sự khác biệt về cơ bản là không đáng kể.
oldboy

10

Đối với một số nguyên ngẫu nhiên có phạm vi, hãy thử:

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

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

Để kiểm tra chức năng này và các biến thể của chức năng này, hãy lưu HTML / JavaScript bên dưới vào một tệp và mở bằng trình duyệt. Mã này sẽ tạo ra một biểu đồ hiển thị phân phối của một triệu lệnh gọi hàm. Mã cũng sẽ ghi lại các trường hợp cạnh, vì vậy nếu hàm tạo ra giá trị lớn hơn max hoặc nhỏ hơn min, you.will.kn.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">&nbsp;[' + (i + min - 1) + ']:&nbsp;'+array[i]+'</span>&nbsp;&nbsp;');
        }
        document.write('<hr/>');
        </script>
    </head>
    <body>

    </body>
</html>

7

Để có được một số ngẫu nhiên, từ 1 đến 6, trước tiên hãy làm:

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

Điều này nhân một số ngẫu nhiên với 6 và sau đó cộng 0,5 vào nó. Tiếp theo làm tròn số đến một số nguyên dương bằng cách thực hiện:

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

Điều này làm tròn số đến số nguyên gần nhất.

Hoặc để làm cho nó dễ hiểu hơn làm điều này:

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

Nói chung, mã để làm điều này bằng cách sử dụng các biến là:

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

Lý do lấy đi 0,5 từ giá trị tối thiểu là bởi vì chỉ sử dụng giá trị tối thiểu sẽ cho phép bạn có được một số nguyên nhiều hơn một giá trị tối đa của bạn. Bằng cách lấy đi 0,5 từ giá trị tối thiểu, về cơ bản, bạn đang ngăn chặn giá trị tối đa được làm tròn lên.

Mong rằng sẽ giúp.


Có ý nghĩa nếu bạn loại trừ 0 , thì không cần phải "làm tròn xuống" trong phạm vi từ 0 đến 0,5.
ILMostro_7

7

Sử dụng mã sau đây, bạn có thể tạo ra các dãy số ngẫu nhiên, không lặp lại, trong một phạm vi nhất định.

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

7

Tôi biết câu hỏi này đã được trả lời nhưng câu trả lời của tôi có thể giúp được ai đó.

Tôi tìm thấy phương pháp đơn giản này trên W3Schools:

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

Hy vọng điều này sẽ giúp được ai đó.


1
Math.floor ((Math.random () * 1) + 0); luôn luôn cho 0
madprops

1
@madprops Vì số lượng tối đa là độc quyền. Để lấy 0 hoặc 1, bạn nên đặt 2 là số tối đa.
NutCracker

1
hoặc bạn chỉ cần thêm +1 trong hàm gọi phương thức này
Pietro Coelho

6

Số nguyên ngẫu nhiên giữa thấp nhất và cao nhất:

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

Không phải là giải pháp thanh lịch nhất .. nhưng một cái gì đó nhanh chóng.


5

Đây là những gì tôi sử dụng để tạo số ngẫu nhiên.

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

Chúng tôi thực hiện high++Math.random()tạo ra một số ngẫu nhiên trong khoảng từ 0, (bao gồm) và 1 (độc quyền) Số bị loại trừ, có nghĩa là chúng tôi phải tăng mức cao lên một trước khi thực hiện bất kỳ phép toán nào. Sau đó, chúng tôi trừ thấp từ cao, cho chúng tôi số cao nhất để tạo - thấp, sau đó + thấp, đưa cao trở lại bình thường và làm cho số thấp nhất ít nhất là thấp nhất. sau đó chúng tôi trả về số kết quả

random(7,3) có thể trở lại 3,4,5,6, or 7


2
highchỉ được sử dụng một lần, bạn cũng có thể sử dụng high-low+1thay vì có câu lệnh tăng riêng. Ngoài ra, hầu hết người dùng sẽ mong đợi lowtham số đến trước.
Chris Walsh

4
    <!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 tạo ra một mảng chứa một số có tới 3 chữ số sẽ tối đa là 999. Mã này rất ngắn.


4

Dưới đây là ví dụ về hàm javascript có thể tạo số lượng ngẫu nhiên có độ dài được chỉ định mà không cần sử dụng 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;
    }

t1 / t2 luôn rất gần với 1. và do đó hàm của bạn trả về cùng một số khi hàm được gọi lặp đi lặp lại .. jsbin.com/xogufacera/edit?js,console
Sunil BN

kiểm tra url jsbin .. bạn sẽ thấy đầu ra của chính mình
Sunil BN

Nó hoạt động rất tốt khi độ dài nằm trong khoảng 4-10 (Như tôi đã thử nghiệm trên máy của mình), vì các giá trị của hằng số T1 & T2 nên có khoảng cách phù hợp.
Nilesh Pawar

3

đây là việc tôi lấy một số ngẫu nhiên trong một phạm vi, vì tôi muốn lấy một số ngẫu nhiên trong phạm vi cơ sở để cấp số nhân. ví dụ: cơ sở = 10, số mũ = 2, đưa ra một số ngẫu nhiên từ 0 đến 100, lý tưởng, v.v.

Nếu nó giúp sử dụng nó, đây là:

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

Math.random() nhanh và phù hợp cho nhiều mục đích, nhưng không phù hợp nếu bạn cần các giá trị bảo mật bằng mật mã (không an toàn) hoặc nếu bạn cần số nguyên từ phân phối không thiên vị hoàn toàn thống nhất (phương pháp nhân được sử dụng trong các câu trả lời khác tạo ra một số giá trị nhất định thường xuyên hơn hơn những người khác).

Trong các trường hợp như vậy, chúng tôi có thể sử dụng crypto.getRandomValues()để tạo các số nguyên an toàn và từ chối mọi giá trị được tạo mà chúng tôi không thể ánh xạ đồng nhất vào phạm vi mục tiêu. Điều này sẽ chậm hơn, nhưng nó không đáng kể trừ khi bạn tạo ra số lượng giá trị cực lớn.

Để làm rõ mối quan tâm phân phối thiên vị, hãy xem xét trường hợp chúng tôi muốn tạo giá trị từ 1 đến 5, nhưng chúng tôi có một trình tạo số ngẫu nhiên tạo ra các giá trị từ 1 đến 16 (giá trị 4 bit). Chúng tôi muốn có cùng số lượng ánh xạ giá trị được tạo cho mỗi giá trị đầu ra, nhưng 16 không chia đều cho 5: nó để lại phần còn lại là 1. Vì vậy, chúng tôi cần từ chối 1 trong các giá trị được tạo có thể và chỉ tiếp tục khi chúng tôi nhận được một trong 15 giá trị nhỏ hơn có thể được ánh xạ đồng nhất vào phạm vi mục tiêu của chúng tôi. Hành vi của chúng tôi có thể trông giống như mã giả này:

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.

Đoạn mã sau sử dụng logic tương tự, nhưng thay vào đó tạo ra số nguyên 32 bit, vì đó là kích thước số nguyên phổ biến lớn nhất có thể được biểu thị bằng numberloại tiêu chuẩn của JavaScript . (Điều này có thể được sửa đổi để sử dụng BigInts nếu bạn cần phạm vi lớn hơn.) Bất kể phạm vi đã chọn, phần giá trị được tạo bị từ chối sẽ luôn nhỏ hơn 0,5, vì vậy số lần từ chối dự kiến ​​sẽ luôn nhỏ hơn 1.0 và thường gần bằng 0,0; bạn không cần phải lo lắng về việc lặp đi lặp lại mãi mãi.

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]


3

Tiền điện tử mạnh

Để có được số nguyên ngẫu nhiên mạnh về tiền điện tử trong ragne [x, y] hãy thử

let cs= (x,y)=>x+(y-x+1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32|0

console.log(cs(4,8))


4
cái này thật hấp dẫn
Akin Hwan

1

Bạn có thể cho bạn đoạn mã này,

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

1
Có một dòng trùng lặp không cần thiết ở đây. Chỉ cần sử dụng do - whilethay vìwhile
Javi Marzán

1

Ionuț G. Stan đã viết một câu trả lời tuyệt vời nhưng nó hơi phức tạp đối với tôi. Vì vậy, tôi đã tìm thấy một lời giải thích thậm chí đơn giản hơn về các khái niệm tương tự tại https://teamtreehouse.com/community/mathfloor-mathrandom-max-min-1-min-explanation của Jason Anello.

LƯU Ý: Điều quan trọng duy nhất bạn nên biết trước khi đọc lời giải thích của Jason là định nghĩa về "cắt ngắn". Ông sử dụng thuật ngữ đó khi mô tả Math.floor(). Từ điển Oxford định nghĩa "cắt ngắn" là:

Rút ngắn (một cái gì đó) bằng cách cắt đầu hoặc cuối.


0

Điều này có thể xử lý việc tạo tối đa 20 chữ số UNIITE số ngẫu nhiên

Mã não

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

nhập mô tả hình ảnh ở đây

JsFiddle


Tôi ủng hộ điều này chỉ vì.
Taylor Ackley

1
@TaylorAckley Câu trả lời này không giải quyết được câu hỏi.
RomainValeri

0

/ * Viết hàm gọi là randUpTochấp nhận một số và trả về một số nguyên ngẫu nhiên trong khoảng từ 0 đến số đó? * /

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

/ * Viết hàm gọi là randBetweenchấp nhận hai số đại diện cho một phạm vi và trả về một số nguyên ngẫu nhiên giữa hai số đó. * /

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

/ * Viết một hàm được gọi là randFromTillchấp nhận hai số đại diện cho một phạm vi và trả về một số ngẫu nhiên giữa tối thiểu (bao gồm) và tối đa (loại trừ). * /

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

/ * Viết hàm được gọi là randFromTochấp nhận hai số biểu thị một phạm vi và trả về một số nguyên ngẫu nhiên giữa min (đã bao gồm) và max (đã bao gồm) * /

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

1
Đẹp, bạn cũng có thể lưu ý rằng randB between là (độc quyền) (độc quyền)?
pfdint

0

Tôi đã thực hiện chức năng này trong đó có các tùy chọn tài khoản như min, max, loại trừ (một danh sách các số nguyên để loại trừ) và seed (trong trường hợp bạn muốn một trình tạo ngẫu nhiên có seeded).

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
}

Nó có thể được sử dụng như:

let n = get_random_int
(
    {
        min: 0,
        max: some_list.length - 1,
        exclude: [3, 6, 5],
        seed: my_seed_function
    }
)

Hay đơn giản hơn:

let n = get_random_int
(
    {
        min: 0,
        max: some_list.length - 1
    }
)

Sau đó, bạn có thể làm:

let item = some_list[n]

Gist: https://gist.github.com/madprops/757deb000bdec25776d5036dae58ee6e


0
  • ngẫu nhiên (tối thiểu, tối đa) tạo ra một số ngẫu nhiên giữa tối thiểu (bao gồm) và tối đa (độc quyền)
  • Math.floor làm tròn một số xuống số nguyên gần nhất

    function generateRandomInteger (min, max) { 
        return Math.floor(random(min,max)) 
    }`

Vì vậy, để tạo một số nguyên ngẫu nhiên trong khoảng từ 4 đến 8, hãy gọi hàm trên với các đối số sau:

generateRandomInteger (4,9)

0

Phương pháp tạo số ngẫu nhiên của tôi trong khoảng từ 0 đến n, trong đó n <= 10 (n loại trừ):

Math.floor((Math.random() * 10) % n)
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.