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 = 4
và y = 8
sẽ xuất bất kỳ số 4, 5, 6, 7, 8
nào?
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 = 4
và y = 8
sẽ xuất bất kỳ số 4, 5, 6, 7, 8
nào?
Câu trả lời:
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ề Number
từ 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 min
khoả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.random
và 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 min
lạ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 min
và max
, bao gồm cả.
Bây giờ để có được số nguyên, bạn có thể sử dụng round
, ceil
hoặ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 min
và max
chỉ 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 max
loạ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)) + min
bạ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()
và -1
trong phương trình đó vì max
bây giờ có ít cơ hội hơn để cuộn, nhưng bạn cũng có thể cuộn min-1
kết quả (không mong muốn) .
floor
, mà làm tròn xuống.
round
, nhưng sau đó cả hai, min
và max
chỉ 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 max
số có ít cơ hội lăn hơn do [0,1)
Khoảng thời gian.
var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
(Math.random() * (maximum - minimum + 1) ) << 0
nhanh hơn.
x << 0
, x | 0
, ~~x
) thay vì Math.floor()
cải x
thà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!
657348096152|0
có 218099864 (110011111111111111000010011000 ở dạng nhị phân).
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 ().
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ị bottom
và top
, 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 top
và bottom
, chúng ta sẽ nhận được gấp đôi ở đâu đó giữa 0
và 1+b-a
.
Math.floor( Math.random() * ( 1 + top - bottom ) )
Math.floor
là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 0
và top-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 0
và top-bottom
vì vậy, tất cả những gì chúng tôi cần làm bây giờ là thêm bottom
vào kết quả đó để có được một số nguyên trong phạm vi bottom
và top
bao 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 .
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)
_.uniqueId()
chức năng mà bạn có thể gọi cho các mô hình phía máy khách.
x << 0
, x | 0
, ~~x
) thay vì Math.floor()
cải x
thà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!
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)
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 0
và 1
. Thay vào đó bạn nên sử dụng round
thay vì của ceil
hay 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
console.log(randomNumber(5,6)); # 9 6 6 5 7 7
9 & 7 có nằm trong khoảng từ 5 & 6 không? ...... bạn nên sửa hoặc giải thích ..
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
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 );
}
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)
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ể.
Đố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;
}
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"> [' + (i + min - 1) + ']: '+array[i]+'</span> ');
}
document.write('<hr/>');
</script>
</head>
<body>
</body>
</html>
Để 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.
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;
}
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 đó.
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.
Đâ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++
vì 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
high
chỉ được sử dụng một lần, bạn cũng có thể sử dụng high-low+1
thay vì có câu lệnh tăng riêng. Ngoài ra, hầu hết người dùng sẽ mong đợi low
tham số đến trước.
<!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.
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;
}
đâ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);
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 number
loại tiêu chuẩn của JavaScript . (Điều này có thể được sửa đổi để sử dụng BigInt
s 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]
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;
}
do - while
thay vìwhile
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.
Đ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);
/ * Viết hàm gọi là randUpTo
chấ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à randBetween
chấ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à randFromTill
chấ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à randFromTo
chấ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;
};
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
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)
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)