生成1到100之间的唯一随机数

如何使用 JavaScript 生成一些介于1和100之间的 独一无二的随机数字？

300607 次浏览
小开

生成100个数字的 排列，然后按顺序选择。

使用 Knuth Shuffle (又名 Fisher-Yates Shuffle)算法。

JavaScript:

  function fisherYates ( myArray,stop_count ) {
var i = myArray.length;
if ( i == 0 ) return false;
int c = 0;
while ( --i ) {
var j = Math.floor( Math.random() * ( i + 1 ) );
var tempi = myArray[i];
var tempj = myArray[j];
myArray[i] = tempj;
myArray[j] = tempi;


// Edited thanks to Frerich Raabe
c++;
if(c == stop_count)return;


}
}

从链接复制代码。

编辑:

改进的代码:

function fisherYates(myArray,nb_picks)
{
for (i = myArray.length-1; i > 1  ; i--)
{
var r = Math.floor(Math.random()*i);
var t = myArray[i];
myArray[i] = myArray[r];
myArray[r] = t;
}


return myArray.slice(0,nb_picks);
}

潜在问题:

假设我们有一个100个数字的数组{例如[1,2,3... 100]} ，我们在8次交换后停止交换; 然后大多数乘法数组看起来像{1,2,3,76,5,6,7,8，... 这里的数字将被洗牌... 10}。

因为每个数字的交换概率都是1/100 交换前8个数字的概率是8/100，而交换其他92个数字的概率是92/100。

但是如果我们对整个数组运行算法，那么我们可以确定(几乎)每个条目都被交换了。

否则我们将面临一个问题: 选择哪8个数字？

小开
  1. 用数字1到100填充数组。
  2. 洗牌。
  3. 取得结果数组的前8个元素。
小开
最佳答案

例如: 要生成8个唯一的随机数并将它们存储到一个数组中，你可以简单地这样做:

var arr = [];
while(arr.length < 8){
var r = Math.floor(Math.random() * 100) + 1;
if(arr.indexOf(r) === -1) arr.push(r);
}
console.log(arr);

小开

和魅力机器一样的排列算法，但是有原型实现。更适合大量的选择。如果可用，使用 Js 1.7解构分配。

// swaps elements at index i and j in array this
// swapping is easy on js 1.7 (feature detection)
Array.prototype.swap = (function () {
var i=0, j=1;
try { [i,j]=[j,i]; }
catch (e) {}
if(i) {
return function(i,j) {
[this[i],this[j]] = [this[j],this[i]];
return this;
}
} else {
return function(i,j) {
var temp = this[i];
this[i] = this[j];
this[j] = temp;
return this;
}
}
})();




// shuffles array this
Array.prototype.shuffle = function() {
for(var i=this.length; i>1; i--) {
this.swap(i-1, Math.floor(i*Math.random()));
}
return this;
}


// returns n unique random numbers between min and max
function pick(n, min, max) {
var a = [], i = max;
while(i >= min) a.push(i--);
return a.shuffle().slice(0,n);
}


pick(8,1,100);

编辑: 另一个建议，更适合于少数选择，基于 Belugabob 的答案。为了保证唯一性，我们从数组中删除选中的数字。

// removes n random elements from array this
// and returns them
Array.prototype.pick = function(n) {
if(!n || !this.length) return [];
var i = Math.floor(this.length*Math.random());
return this.splice(i,1).concat(this.pick(n-1));
}


// returns n unique random numbers between min and max
function pick(n, min, max) {
var a = [], i = max;
while(i >= min) a.push(i--);
return a.pick(n);
}


pick(8,1,100);
小开

我会这样做:

function randomInt(min, max) {
return Math.round(min + Math.random()*(max-min));
}
var index = {}, numbers = [];
for (var i=0; i<8; ++i) {
var number;
do {
number = randomInt(1, 100);
} while (index.hasOwnProperty("_"+number));
index["_"+number] = true;
numbers.push(number);
}
delete index;
小开

使用 对象属性作为哈希表怎么样？这样你最好的方案是只随机8次。只有当你想要一小部分数字范围时，它才会有效。与 Fisher-Yates 相比，它的内存密集程度也要低得多，因为不需要为数组分配空间。

var ht={}, i=rands=8;
while ( i>0 || keys(ht).length<rands) ht[Math.ceil(Math.random()*100)]=i--;
alert(keys(ht));

然后我发现 Key (obj)是 ECMAScript 5的一个特性，所以上面的内容现在在互联网上几乎没什么用处。不用担心，因为我通过添加这样的 key 函数使它与 ECMAScript 3兼容。

if (typeof keys == "undefined")
{
var keys = function(obj)
{
props=[];
for (k in ht) if (ht.hasOwnProperty(k)) props.push(k);
return props;
}
}
小开

为了避免任何冗长和不可靠的洗牌，我会做以下..。

  1. 按顺序生成一个包含1到100之间的数字的数组。
  2. 生成1到100之间的随机数
  3. 在数组的这个索引处查找数字并存储结果
  4. 从数组中删除元素，使其缩短
  5. 重复步骤2，但使用99作为随机数的上限
  6. 重复步骤2，但使用98作为随机数的上限
  7. 重复步骤2，但使用97作为随机数的上限
  8. 重复步骤2，但使用96作为随机数的上限
  9. 重复步骤2，但使用95作为随机数的上限
  10. 重复步骤2，但使用94作为随机数的上限
  11. 重复步骤2，但使用93作为随机数的上限

瞧，没有重复的数字。

如果有人感兴趣的话，我可能稍后会发布一些实际的代码。

编辑: 这可能是我天生的好胜心，但是在看了@Alsciende 的帖子后，我忍不住发布了我承诺过的代码。

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<head>
<title>8 unique random number between 1 and 100</title>
<script type="text/javascript" language="Javascript">
function pick(n, min, max){
var values = [], i = max;
while(i >= min) values.push(i--);
var results = [];
var maxIndex = max;
for(i=1; i <= n; i++){
maxIndex--;
var index = Math.floor(maxIndex * Math.random());
results.push(values[index]);
values[index] = values[maxIndex];
}
return results;
}
function go(){
var running = true;
do{
if(!confirm(pick(8, 1, 100).sort(function(a,b){return a - b;}))){
running = false;
}
}while(running)
}
</script>
</head>


<body>
<h1>8 unique random number between 1 and 100</h1>
<p><button onclick="go()">Click me</button> to start generating numbers.</p>
<p>When the numbers appear, click OK to generate another set, or Cancel to stop.</p>
</body>

小开

将数字从1洗牌到100是正确的基本策略，但是如果你只需要8个洗牌的数字，就没有必要将所有100个数字都洗牌。

我不太了解 Javascript，但是我相信快速创建一个100个空值的数组是很容易的。然后，在8轮中，将数组的非 h 元素(n 从0开始)与从 n + 1到99的随机选择的元素交换。当然，任何尚未填充的元素都意味着该元素实际上是原始索引加1，因此考虑这个因素并不重要。当你完成8个回合后，你的数组的前8个元素将会有你的8个被洗牌的数字。

小开 
var bombout=0;
var checkArr=[];
var arr=[];
while(arr.length < 8 && bombout<100){
bombout++;
var randomNumber=Math.ceil(Math.random()*100);
if(typeof checkArr[randomNumber] == "undefined"){
checkArr[randomNumber]=1;
arr.push(randomNumber);
}
}​


// untested - hence bombout
小开

如果需要更多惟一性，则必须生成一个数组(1. .100)。

var arr=[];
function generateRandoms(){
for(var i=1;i<=100;i++) arr.push(i);
}
function extractUniqueRandom()
{
if (arr.length==0) generateRandoms();
var randIndex=Math.floor(arr.length*Math.random());
var result=arr[randIndex];
arr.splice(randIndex,1);
return result;


}
function extractUniqueRandomArray(n)
{
var resultArr=[];
for(var i=0;i<n;i++) resultArr.push(extractUniqueRandom());
return resultArr;
}

以上代码更快:
ExtractUniqueRandomArray (50) = > [2,79,38,59,63,42,52,22,78,50,39,77,1,88,40,23,48,84,91,49,4,54,93,36,100,82,62,41,89,12,24,31,86,92,64,75,70,61,67,98,76,80,56,90,83,44,43,47,7,53]

小开

对于带有像这样 [,2,,4,,6,7,,]的孔的数组 因为我的问题是填补这些漏洞。所以我根据自己的需要修改了它:)

以下修改后的解决方案对我有效:)

var arr = [,2,,4,,6,7,,]; //example
while(arr.length < 9){
var randomnumber=Math.floor(Math.random()*9+1);
var found=false;
for(var i=0;i<arr.length;i++){
if(arr[i]==randomnumber){found=true;break;}
}


if(!found)
for(k=0;k<9;k++)
{if(!arr[k]) //if it's empty  !!MODIFICATION
{arr[k]=randomnumber; break;}}
}


alert(arr); //outputs on the screen
小开

使用 JavaScript 1.6 indexOf 函数添加同一代码的另一个更好版本(可接受的答案)。不需要每次检查副本时都循环遍历整个数组。

var arr = []
while(arr.length < 8){
var randomnumber=Math.ceil(Math.random()*100)
var found=false;
if(arr.indexOf(randomnumber) > -1){found=true;}
if(!found)arr[arr.length]=randomnumber;
}

旧版本的 Javascript 仍然可以使用顶部的版本

PS: 我试图建议更新维基，但是被拒绝了。我仍然认为它可能对其他人有用。

小开

这是我个人的解决方案:

<script>


var i, k;
var numbers = new Array();
k = Math.floor((Math.random()*8));
numbers[0]=k;
for (var j=1;j<8;j++){
k = Math.floor((Math.random()*8));
i=0;
while (i < numbers.length){
if (numbers[i] == k){
k = Math.floor((Math.random()*8));
i=0;
}else {i++;}
}
numbers[j]=k;
}
for (var j=0;j<8;j++){
alert (numbers[j]);
}
</script>

它随机生成8个唯一的数组值(介于0和7之间) ，然后使用警告框显示它们。

小开

最好的早期答案是 sje397的答案。你会得到尽可能好的随机数，越快越好。

我的解决方案和他的非常相似。然而，有时候你需要随机的数字顺序，这就是为什么我决定张贴一个答案。此外，我还提供了一个通用函数。

function selectKOutOfN(k, n) {
if (k>n) throw "k>n";
var selection = [];
var sorted = [];
for (var i = 0; i < k; i++) {
var rand = Math.floor(Math.random()*(n - i));
for (var j = 0; j < i; j++) {
if (sorted[j]<=rand)
rand++;
else
break;
}
selection.push(rand);
sorted.splice(j, 0, rand);
}
return selection;
}


alert(selectKOutOfN(8, 100));
小开

如果你想避免使用库，上面的技术是很好的，但是如果你想使用库，我建议你使用 Chance来生成随机的 JavaScript 代码。

特别是为了解决你的问题，使用 Chance 就像下面这样简单:

// One line!
var uniques = chance.unique(chance.natural, 8, {min: 1, max: 100});


// Print it out to the document for this snippet so we can see it in action
document.write(JSON.stringify(uniques));
<script src="http://chancejs.com/chance.min.js"></script>

Disclaimer, as the author of Chance, I am a bit biased ;)

小开 
function getUniqueRandomNos() {
var indexedArrayOfRandomNo = [];
for (var i = 0; i < 100; i++) {
var randNo = Math.random();
indexedArrayOfRandomNo.push([i, randNo]);
}
indexedArrayOfRandomNo.sort(function (arr1, arr2) {
return arr1[1] - arr2[1]
});
var uniqueRandNoArray = [];
for (i = 0; i < 8; i++) {
uniqueRandNoArray.push(indexedArrayOfRandomNo[i][0]);
}
return uniqueRandNoArray;
}

我认为这种方法不同于大多数答案中给出的方法，所以我想我可以在这里添加一个答案(尽管这个问题是4年前提出的)。

我们生成100个随机数，并在每个数字上标记从1到100的数字。然后我们把这些带标签的随机数字排序，这些标签被随机地打乱。或者，根据这个问题的需要，我们可以只找到标记的随机数的前8位。找到前8个项目比排序整个数组要便宜。

必须注意的是排序算法影响了这个算法。如果使用的排序算法是稳定的，那么就会稍微倾向于使用较小的数字。理想情况下，我们希望排序算法是不稳定的，甚至不会偏向于稳定(或不稳定) ，从而得出一个概率分布完全一致的答案。

小开

这是我编写的一个非常通用的函数，用于为数组生成随机唯一/非唯一整数。在这个场景中，假设这个答案的最后一个参数为 true。

/* Creates an array of random integers between the range specified
len = length of the array you want to generate
min = min value you require
max = max value you require
unique = whether you want unique or not (assume 'true' for this answer)
*/
function _arrayRandom(len, min, max, unique) {
var len = (len) ? len : 10,
min = (min !== undefined) ? min : 1,
max = (max !== undefined) ? max : 100,
unique = (unique) ? unique : false,
toReturn = [], tempObj = {}, i = 0;


if(unique === true) {
for(; i < len; i++) {
var randomInt = Math.floor(Math.random() * ((max - min) + min));
if(tempObj['key_'+ randomInt] === undefined) {
tempObj['key_'+ randomInt] = randomInt;
toReturn.push(randomInt);
} else {
i--;
}
}
} else {
for(; i < len; i++) {
toReturn.push(Math.floor(Math.random() * ((max - min) + min)));
}
}


return toReturn;
}

在这里，‘ temObj’是一个非常有用的 obj，因为如果这个键已经存在，每个生成的随机数都会直接检入 temObj，如果不存在，那么我们将 i 减少一个，因为我们需要额外运行一次，因为当前的随机数已经存在。

在您的情况下，运行以下命令

_arrayRandom(8, 1, 100, true);

仅此而已。

小开 
var arr = []
while(arr.length < 8){
var randomnumber=Math.ceil(Math.random()*100)
if(arr.indexOf(randomnumber) === -1){arr.push(randomnumber)}
}
document.write(arr);

比我见过的其他答案都短

小开

这可以处理生成多达20位的 UNIQUE 随机数

JS

 var generatedNumbers = [];


function generateRandomNumber(precision) { // input --> 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);

enter image description here

JsFiddle

小开

这个解决方案使用散列，它比检查散列是否驻留在数组中性能更好。还有额外的安全检查。希望能有帮助。

function uniqueArray(minRange, maxRange, arrayLength) {
var arrayLength = (arrayLength) ? arrayLength : 10
var minRange = (minRange !== undefined) ? minRange : 1
var maxRange = (maxRange !== undefined) ? maxRange : 100
var numberOfItemsInArray = 0
var hash = {}
var array = []


if ( arrayLength > (maxRange - minRange) ) throw new Error('Cannot generate unique array: Array length too high')


while(numberOfItemsInArray < arrayLength){
// var randomNumber = Math.floor(Math.random() * (maxRange - minRange + 1) + minRange)
// following line used for performance benefits
var randomNumber = (Math.random() * (maxRange - minRange + 1) + minRange) << 0


if (!hash[randomNumber]) {
hash[randomNumber] = true
array.push(randomNumber)
numberOfItemsInArray++
}
}
return array
}
document.write(uniqueArray(1, 100, 8))
小开

以生成器的形式实现这一点使得使用它非常方便。注意，这个实现不同于要求首先对整个输入数组进行洗牌的实现。

这个 sample函数工作缓慢，每次迭代都给出 1随机项，直到您请求的 N项为止。这是很好的，因为如果你只想从 1000列表的 3项目，你不必触摸所有1000项目第一。

// sample :: Integer -> [a] -> [a]
const sample = n => function* (xs) {
let ys = xs.slice(0);
let len = xs.length;
while (n > 0 && len > 0) {
let i = (Math.random() * len) >> 0;
yield ys.splice(i,1)[0];
n--; len--;
}
}


// example inputs
let items = ['a', 'b', 'c', 'd', 'e', 'f', 'g'];
let numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];


// get 3 random items
for (let i of sample(3) (items))
console.log(i); // f g c


// partial application
const lotto = sample(3);
for (let i of lotto(numbers))
console.log(i); // 3 8 7


// shuffle an array
const shuffle = xs => Array.from(sample (Infinity) (xs))
console.log(shuffle(items)) // [b c g f d e a]

我选择的实现 sample的方式不会改变输入数组，但是您可以很容易地认为改变实现是有利的。

例如，shuffle函数可能希望对原始输入数组进行变异。或者您可能希望在不同的时间从相同的输入中取样，每次更新输入。

// sample :: Integer -> [a] -> [a]
const sample = n => function* (xs) {
let len = xs.length;
while (n > 0 && len > 0) {
let i = (Math.random() * len) >> 0;
yield xs.splice(i,1)[0];
n--; len--;
}
}


// deal :: [Card] -> [Card]
const deal = xs => Array.from(sample (2) (xs));


// setup a deck of cards (13 in this case)
// cards :: [Card]
let cards = 'A234567890JQK'.split('');


// deal 6 players 2 cards each
// players :: [[Card]]
let players = Array.from(Array(6), $=> deal(cards))


console.log(players);
// [K, J], [6, 0], [2, 8], [Q, 7], [5, 4], [9, A]


// `cards` has been mutated. only 1 card remains in the deck
console.log(cards);
// [3]

由于数组输入突变，sample不再是 纯洁函数，但在某些情况下(如上所示) ，它可能更有意义。

我选择生成器而不是仅返回数组的函数的另一个原因是，您可能希望继续采样，直到出现某些特定的条件。

也许我想要的是100万个随机数列表中的第一个质数。

  • “我应该取样多少?”-您不必指定
  • “我必须先找到所有的素数，然后选择一个随机的素数吗?”-不。

因为我们使用的是生成器，所以这个任务很简单

const randomPrimeNumber = listOfNumbers => {
for (let x of sample(Infinity) (listOfNumbers)) {
if (isPrime(x))
return x;
}
return NaN;
}

这将连续不断地采样1个随机数，x，检查它是否是质数，然后返回 x如果它是。如果在找到素数之前数字列表已经用尽，则返回 NaN。

注:

这个答案 最初是在另一个问题上分享的，这个问题作为这个问题的副本被关闭了。因为它与这里提供的其他解决方案非常不同，所以我决定也在这里分享它

小开

你也可以像这样使用一行代码:

[...((add, set) => add(set, add))((set, add) => set.size < 8 ? add(set.add(Math.floor(Math.random()*100) + 1), add) : set, new Set())]

小开

使用 预备(和平均情况 O (n))的现代 JS 解决方案

const nums = new Set();
while(nums.size !== 8) {
nums.add(Math.floor(Math.random() * 100) + 1);
}


console.log([...nums]);

小开 
getRandom (min, max) {
return Math.floor(Math.random() * (max - min)) + min
}


getNRandom (min, max, n) {
const numbers = []
if (min > max) {
return new Error('Max is gt min')
}


if (min === max) {
return [min]
}


if ((max - min) >= n) {
while (numbers.length < n) {
let rand = this.getRandom(min, max + 1)
if (numbers.indexOf(rand) === -1) {
numbers.push(rand)
}
}
}


if ((max - min) < n) {
for (let i = min; i <= max; i++) {
numbers.push(i)
}
}
return numbers
}
小开

另一种方法是生成一个具有升序数字的100个条目数组，并对其进行随机排序。这实际上导致了一个非常简短和(在我看来)简单的片段。

const numbers = Array(100).fill().map((_, index) => index + 1);
numbers.sort(() => Math.random() - 0.5);
console.log(numbers.slice(0, 8));

小开

使用 Set是最快的选择。下面是一个通用函数，用于获取使用回调生成器的唯一随机值。现在是 很快和 可重复使用。

// Get a unique 'anything'
let unique = new Set()


function getUnique(generator) {
let number = generator()
while (!unique.add(number)) {
number = generator()
}
return number;
}


// The generator.  Return anything, not just numbers.
const between_1_100 = () => 1 + Math.floor(Math.random() * 100)


// Test it
for (var i = 0; i < 8; i++) {
const aNumber = getUnique(between_1_100)
}
// Dump the 'stored numbers'
console.log(Array.from(unique))

小开

这是我的 ES6版本，我拼凑在一起。我相信它可以更加统一一点。

function randomArray(i, min, max) {
min = Math.ceil(min);
max = Math.floor(max);
  

let arr = Array.from({length: i}, () => Math.floor(Math.random()* (max - min)) + min);
  

return arr.sort();
}
 

let uniqueItems = [...new Set(randomArray(8, 0, 100))]
console.log(uniqueItems);

小开

这是 Fisher Yates/Durstenfeld Shuffle的一个实现，但是没有实际创建数组，因此减少了所需的空间复杂度或内存，当拣选器的大小与可用元素的数量相比较小时。

要从100中选择8个数字，没有必要创建一个包含100个元素的数组。

假设创建了一个数组,

  • 从数组(100)的末尾，得到从1到100的随机数(rnd)
  • 交换100和随机数 rnd
  • 用 array (99)重复步骤1

如果未创建数组，则可以使用 hashMap 记住实际交换的位置。当生成的第二个随机数等于先前生成的数字之一时，映射提供该位置的当前值，而不是实际值。

const getRandom_ = (start, end) => {
return Math.floor(Math.random() * (end - start + 1)) + start;
};
const getRealValue_ = (map, rnd) => {
if (map.has(rnd)) {
return getRealValue_(map, map.get(rnd));
} else {
return rnd;
}
};
const getRandomNumbers = (n, start, end) => {
const out = new Map();
while (n--) {
const rnd = getRandom_(start, end--);
out.set(getRealValue_(out, rnd), end + 1);
}
return [...out.keys()];
};


console.info(getRandomNumbers(8, 1, 100));
console.info(getRandomNumbers(8, 1, Math.pow(10, 12)));
console.info(getRandomNumbers(800000, 1, Math.pow(10, 15)));

小开

下面是一个从0到100(包括0和100)的范围内随机抽取的5个数字的例子，它们没有重复。

let finals = [];
const count = 5; // Considering 5 numbers
const max = 100;


for(let i = 0; i < max; i++){
const rand = Math.round(Math.random() * max);
!finals.includes(rand) && finals.push(rand)
}


finals = finals.slice(0, count)
小开 

var numbers = [];


for (let i = 0; i < 8; i++) {
let a = true,
n;
while(a) {
n = Math.floor(Math.random() * 100) + 1;
a = numbers.includes(n);
}
numbers.push(n);
}


console.log(numbers);

小开

我在 ES6中就是这样做的，而且不用 while。这也不会返回0。

function randomUniqueIntegers(total, quantity) {
  

const numbers = Array(total)
.fill(null)
.map((_, i) => i+1);
  

return numbers
.map((value) => ({ value, sort: Math.random() }))
.sort((a, b) => a.sort - b.sort)
.map(({ value }) => value)
.slice(0, quantity);
}


randomUniqueIntegers(100, 8) //[ 79, 28, 97, 17, 23, 70, 20, 12 ]

如果这里有用户输入，您可能还需要进行一些错误处理。

小开

有很多选择，但大部分都是相似的算法。 我决定重新编译它们，并做一个基准测试。 您可以看到一个 源代码。请随意使用附加函数或更正请求。

我建议使用 预备版本:

/**
* Get set of unique numbers from the renge between 0 and {max}
* @param {number} max The top number of the renge 0..max (will not be included in the result)
* @param {number} qty The amount of unique numbers from the renge Must be less or equal to {max}
* @returns {Array<number>} List of unique random numbers from the renge (0 <= random number < max)
*/
export default function uniqueIndexes(max, qty) {
const retVal = new Set;
while (retVal.size < qty) {
retVal.add(Math.floor(Math.random() * max));
}
return Array.from(retVal);
}

当您需要获得与数组大小无关的少量唯一随机数时，此函数将给出第二个结果。 当你需要一组更大的唯一数时，它仍然有很好的性能。

并且我强烈建议不要使用 洗牌算法，这是几个人在本主题中建议的。Shuffle 算法在性能方面是最差的，它比我推荐的算法慢25倍，如果你在高需求的服务器上使用更大的数组，或者制作一些基于网络的游戏，它可能会有一些影响。而且当你有一个更大的数值范围时，它的性能会成指数级地变差。

在我的测试示例中，在0到1000之间，它在 300！中的运行速度比推荐的方法慢一倍。

下面是基准测试的结果。

  • 测试10000次(100次中有80次是唯一的)

洗牌功能耗时205.500毫秒——-越来越糟

散列函数耗时48.448 ms-最好的

设置功能花费了77.849毫秒——-合情合理

IndexOf 函数耗时105.924毫秒

  • 测试10000x (100分中的10分)

洗牌功能耗时203.991毫秒-越来越糟

散列函数耗时11.478毫秒

设置功能花了8.007毫秒-合理

IndexOf 函数用了4.859 ms ——-最好的

  • 测试10000x (1000分中的10分)

洗牌功能耗时2772.697 ms ——-哇，没有词语(但预期)

散列函数耗时29.295毫秒

设置功能花了8.435毫秒-合理

IndexOf 函数用了4.792 ms ——-最好的


提交答案