Générer des nombres aléatoires uniques entre 1 et 100
Comment générer 8, par exemple, des nombres aléatoires uniques compris entre 1 et 100 en utilisant JavaScript?
var arr = []
while(arr.length < 8){
var r = Math.floor(Math.random()*100) + 1;
if(arr.indexOf(r) === -1) arr.Push(r);
}
document.write(arr);- Remplissez un tableau avec les nombres de 1 à 100.
- Mélangez .
- Prenez les 8 premiers éléments du tableau résultant.
Générez permutation de 100 nombres, puis choisissez les uns à la suite des autres.
Utilisez Knuth Shuffle (aussi appelé algorithme de Fisher-Yates) .
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;
}
}
MODIFIER:
Code amélioré:
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);
}
Problème potentiel:
Supposons que nous ayons un tableau de 100 nombres {par exemple. [1,2,3 ... 100]} et nous arrêtons l'échange après 8 échanges; La plupart du temps tableau ressemblera à {1,2,3,76,5,6,7,8 ,. ..nombers ici seront mélangés ... 10}.
Parce que chaque nombre sera échangé avec une probabilité de 1/100, donc Prob. de permuter les 8 premiers nombres est 8/100 alors que prob. d’échanger 92 autres est 92/100.
Mais si nous exécutons un algorithme pour un tableau complet, nous sommes sûrs que (presque) chaque entrée est permutée.
Sinon, nous sommes confrontés à une question: quels 8 chiffres choisir?
Les techniques ci-dessus sont utiles si vous souhaitez éviter une bibliothèque, mais si vous êtes d'accord avec une bibliothèque, je vous suggère de vérifier Chance pour générer des éléments aléatoires en JavaScript.
Pour résoudre spécifiquement votre question, utilisez Chance, c'est aussi simple que:
// 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, en tant qu'auteur de Chance, je suis un peu partial;)
Pour éviter les mélanges longs et peu fiables, je ferais ce qui suit ...
- Générez un tableau contenant le nombre entre 1 et 100, dans l'ordre.
- Générer un nombre aléatoire compris entre 1 et 100
- Recherchez le nombre à cet index dans le tableau et stockez-le dans vos résultats
- Supprimez l'elemnt du tableau, le rendant plus court
- Répétez à partir de l'étape 2, mais utilisez 99 comme limite supérieure du nombre aléatoire
- Répétez à partir de l'étape 2, mais utilisez 98 comme limite supérieure du nombre aléatoire.
- Répétez à partir de l'étape 2, mais utilisez 97 comme limite supérieure du nombre aléatoire
- Répétez à partir de l'étape 2, mais utilisez 96 comme limite supérieure du nombre aléatoire
- Répétez à partir de l'étape 2, mais utilisez 95 comme limite supérieure du nombre aléatoire
- Répétez à partir de l'étape 2, mais utilisez 94 comme limite supérieure du nombre aléatoire
- Répétez à partir de l'étape 2, mais utilisez 93 comme limite supérieure du nombre aléatoire
Voila - pas de chiffres répétés.
Je pourrais poster du code réel plus tard, si cela intéresse quelqu'un.
Edit: C'est probablement la phase de compétition en moi mais, après avoir vu le message de @Alsciende, je n'ai pas pu résister à la publication du code que j'avais promis.
<!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>
Solution JS moderne utilisant Set (et cas moyen O (n))
const nums = new Set();
while(nums.size !== 8) {
nums.add(Math.floor(Math.random() * 100) + 1);
}
console.log([...nums]);C’est une fonction très générique que j’ai écrite pour générer des entiers aléatoires uniques/non uniques pour un tableau. Supposons que le dernier paramètre soit vrai dans ce scénario pour cette réponse.
/* 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;
}
Ici, le 'tempObj' est un obj très utile puisque chaque nombre aléatoire généré va directement vérifier dans ce tempObj si cette clé existe déjà, sinon, nous réduisons le i de un car nous avons besoin d'un cycle supplémentaire puisque le nombre aléatoire actuel existe .
Dans votre cas, lancez ce qui suit
_arrayRandom(8, 1, 100, true);
C'est tout.
Je voudrais faire ceci:
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;
Mélanger les chiffres de 1 à 100 est la bonne stratégie de base, mais si vous n'avez besoin que de 8 numéros mélangés, vous n'avez pas besoin de mélanger les 100 numéros.
Je ne connais pas très bien le langage Javascript, mais j'estime qu'il est facile de créer rapidement un tableau de 100 valeurs nuls. Ensuite, pendant 8 tours, vous permutez le nième élément du tableau (n commençant à 0) par un élément sélectionné aléatoirement de n + 1 à 99. Bien entendu, tous les éléments non encore remplis signifient que l'élément aurait vraiment été l'index d'origine plus 1, il est donc trivial de prendre en compte. Lorsque vous avez terminé avec les 8 tours, les 8 premiers éléments de votre tableau auront vos 8 numéros mélangés.
pour les tableaux avec des trous comme celui-ci [,2,,4,,6,7,,] Alors je l'ai modifié selon mes besoins :)
la solution modifiée suivante a fonctionné pour moi :)
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
Même algorithme de permutation que The Machine Charmer, mais avec une implémentation prototypée. Mieux adapté à un grand nombre de choix. Utilise js 1.7 affectation de déstructuration si disponible.
// 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);
Edit: Une autre proposition, mieux adaptée à un petit nombre de choix, basée sur la réponse du bélugabob. Pour garantir l'unicité, nous supprimons les nombres choisis du tableau.
// 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);
La meilleure réponse est la réponse de sje397. Vous obtiendrez des nombres aléatoires aussi bons que possible, le plus rapidement possible.
Ma solution est très similaire à sa solution. Cependant, vous voulez parfois que les nombres aléatoires soient dans un ordre aléatoire et c'est pourquoi j'ai décidé d'envoyer une réponse. De plus, je fournis une fonction générale.
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));
var arr = []
while(arr.length < 8){
var randomnumber=Math.ceil(Math.random()*100)
if(arr.indexOf(randomnumber) === -1){arr.Push(randomnumber)}
}
document.write(arr);
plus courte que d'autres réponses que j'ai vues
Utiliser une Set est votre option la plus rapide. Voici une fonction générique pour obtenir un aléatoire unique qui utilise un générateur de rappel. Maintenant c'est rapide et réutilisable .
// 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))Ajouter une autre version améliorée du même code (réponse acceptée) avec la fonction JavaScript 1.6 indexOf. Vous n'avez pas besoin de parcourir tout le tableau à chaque fois que vous vérifiez le doublon.
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;
}
L'ancienne version de Javascript peut toujours utiliser la version en haut
PS: J'ai essayé de suggérer une mise à jour du wiki mais cela a été rejeté. Je pense toujours que cela peut être utile pour les autres.
Ceci est ma solution personnelle:
<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>
Il génère de manière aléatoire 8 valeurs de tableau uniques (entre 0 et 7), puis les affiche à l'aide d'un champ d'alerte.
si vous avez besoin de plus d'unicité, vous devez générer un tableau (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;
}
le code ci-dessus est plus rapide:
.________ , 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]
Cette solution utilise le hachage qui est beaucoup plus performant O(1) que de vérifier si le réside dans le tableau. Il comporte également des contrôles sécurisés supplémentaires. J'espère que ça aide.
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))
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
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
}
Voici ma version ES6 que j'ai bricolé. Je suis sûr que cela peut être un peu plus consolidé.
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);Cela peut gérer la génération d'un nombre aléatoire UNIQUE jusqu'à 20 chiffres
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);
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;
}
Je pense que cette méthode est différente des méthodes données dans la plupart des réponses, alors je pensais pouvoir ajouter une réponse ici (bien que la question ait été posée il y a 4 ans).
Nous générons 100 nombres aléatoires et étiquetons chacun d'eux avec des nombres de 1 à 100. Nous trions ensuite ces nombres aléatoires étiquetés et les étiquettes sont mélangées de manière aléatoire. Alternativement, si nécessaire dans cette question, on pourrait se contenter de trouver le top 8 des nombres aléatoires marqués. Trouver le top 8 des articles coûte moins cher que de trier tout le tableau .
Il faut noter ici que l'algorithme de tri influence cet algorithme. Si l'algorithme de tri utilisé est stable, il existe un léger biais en faveur des nombres plus petits. Idéalement, nous voudrions que l'algorithme de tri soit instable et ne soit même pas biaisé en faveur de la stabilité (ou de l'instabilité) pour produire une réponse avec une distribution de probabilité parfaitement uniforme.
Travailler avec cela en tant que générateur rend le travail agréable. Notez que cette implémentation diffère de celles qui nécessitent que tout le tableau en entrée soit mélangé en premier.
Cette fonction
samplefonctionne paresseusement, vous donnant 1 élément aléatoire par itération jusqu'àNéléments que vous demandez. C'est bien parce que si vous voulez juste 3 éléments dans une liste de 1000, vous n'avez pas à toucher d'abord les 1000 éléments.
// 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]J'ai choisi d'implémenter sample d'une manière qui ne mute pas le tableau d'entrée, mais vous pouvez facilement dire qu'une implémentation en mutation est favorable.
Par exemple, la fonction shuffle peut souhaiter muter le tableau d'entrée d'origine. Ou vous pouvez souhaiter échantillonner à partir de la même entrée à différents moments, en mettant à jour l'entrée à chaque fois.
// 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 n'est plus une fonction pure en raison de la mutation d'entrée du tableau, mais dans certaines circonstances (voir ci-dessus), cela peut sembler plus logique.
Une autre raison pour laquelle j'ai choisi un générateur au lieu d'une fonction qui renvoie simplement un tableau est que vous souhaitez peut-être continuer l'échantillonnage jusqu'à une condition spécifique.
Je veux peut-être le premier nombre premier d'une liste de 1 000 000 de nombres aléatoires.
- "Combien dois-je échantillonner?" - vous n'avez pas à spécifier
- "Dois-je d'abord trouver tous les nombres premiers, puis choisir un nombre premier aléatoire?" - Non.
Parce que nous travaillons avec un générateur, cette tâche est triviale
const randomPrimeNumber = listOfNumbers => {
for (let x of sample(Infinity) (listOfNumbers)) {
if (isPrime(x))
return x;
}
return NaN;
}
Ceci va échantillonner continuellement un nombre aléatoire à la fois, x, vérifier s'il est premier, puis renvoyer x si c'est le cas. Si la liste de nombres est épuisée avant qu'un nombre premier ne soit trouvé, NaN est renvoyé.
Remarque:
Cette réponse a été partagée à l'origine sur une autre question qui a été fermée en double de celle-ci. Parce que c'est très différent des autres solutions fournies ici, j'ai décidé de le partager ici aussi
Une autre approche plus simple consiste à générer un tableau de 100 éléments avec des nombres croissants et à le trier de manière aléatoire. Cela conduit en fait à un extrait très court et (à mon avis) simple.
function randomNumbers() {
const numbers = [ ...Array(100).keys() ].map(num => num + 1);
numbers.sort(() => Math.random() - 0.5);
return numbers.slice(0, 8);
}
Pourquoi ne pas utiliser les propriétés d'un objet comme table de hachage ? De cette façon, votre meilleur scénario consiste à ne randomiser que 8 fois. Cela ne serait efficace que si vous voulez une petite partie de la plage de chiffres. Elle nécessite également beaucoup moins de mémoire que Fisher-Yates, car vous n'avez pas besoin d'allouer d'espace pour un tableau.
var ht={}, i=rands=8;
while ( i>0 || keys(ht).length<rands) ht[Math.ceil(Math.random()*100)]=i--;
alert(keys(ht));
J'ai alors découvert que Object.keys (obj) est une fonctionnalité ECMAScript 5, donc ce qui précède est quasiment inutile sur les internets pour le moment. Ne craignez rien, car je l'ai rendu compatible avec ECMAScript 3 en ajoutant une fonction de clé comme celle-ci.
if (typeof keys == "undefined")
{
var keys = function(obj)
{
props=[];
for (k in ht) if (ht.hasOwnProperty(k)) props.Push(k);
return props;
}
}