1에서 100 사이의 고유 한 난수 생성

Question 1

JavaScript를 사용하여 1에서 100 사이의 고유 한 난수를 생성하려면 어떻게 해야합니까?

Question 2

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

스 니펫 확장

Question 3

1부터 100까지의 숫자로 배열을 채 웁니다.
셔플합니다 .
결과 배열의 처음 8 개 요소를 가져옵니다.

Question 4

100 개의 숫자 순열 을 생성 한 다음 순차적으로 선택합니다.

사용 크 누스 셔플 (일명 피셔 - 예이츠 셔플) 알고리즘 .

자바 스크립트 :

  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이지만 prob입니다. 다른 92 개의 스와핑은 92/100입니다.

그러나 전체 배열에 대해 알고리즘을 실행하면 (거의) 모든 항목이 스왑된다는 것을 확신합니다.

그렇지 않으면 우리는 어떤 8 개의 숫자를 선택해야할까요?

Question 5

Set (및 평균 케이스 O (n))을 사용한 최신 JS 솔루션

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

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

스 니펫 확장

Question 6

위의 기술은 라이브러리를 피하고 싶다면 좋지만, 라이브러리를 사용해도 괜찮을지 여부에 따라 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>

스 니펫 확장

면책 조항, Chance의 저자로서 나는 약간 편견이 있습니다.)

Question 7

길고 신뢰할 수없는 셔플을 피하기 위해 다음을 수행합니다.

순서대로 1에서 100 사이의 숫자를 포함하는 배열을 생성합니다.
1에서 100 사이의 난수 생성
배열의이 인덱스에서 숫자를 찾아 결과에 저장하십시오.
어레이에서 elemnt를 제거하여 더 짧게 만듭니다.
2 단계부터 반복하되 99를 난수의 상한으로 사용합니다.
2 단계부터 반복하되 난수의 상한으로 98을 사용합니다.
2 단계부터 반복하되 난수의 상한으로 97을 사용합니다.
2 단계부터 반복하되 난수의 상한으로 96을 사용합니다.
2 단계부터 반복하되 95를 난수의 상한으로 사용합니다.
2 단계부터 반복하되 난수의 상한으로 94를 사용합니다.
2 단계부터 반복하되 난수의 상한으로 93을 사용합니다.

Voila-반복되는 숫자가 없습니다.

누군가 관심이 있다면 나중에 실제 코드를 게시 할 수 있습니다.

편집 : 그것은 아마도 나에게 경쟁적인 연속이지만 @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>

Question 8

또 다른 방법은 오름차순 숫자가있는 100 개 항목 배열을 생성하고 무작위로 정렬하는 것입니다. 이것은 실제로 매우 짧고 (내 의견으로는) 간단한 스 니펫으로 이어집니다.

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

스 니펫 확장

Question 9

나는 이것을 할 것이다 :

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;

Question 10

이것은 배열에 대해 임의의 고유하거나 고유하지 않은 정수를 생성하기 위해 작성한 매우 일반적인 함수입니다. 이 답변에 대해이 시나리오에서 마지막 매개 변수가 참이라고 가정합니다.

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

여기서 'tempObj'는 생성 된 모든 난수가이 tempObj에서 해당 키가 이미 존재하는지 직접 확인하기 때문에 매우 유용한 obj입니다. .

귀하의 경우 다음을 실행하십시오.

_arrayRandom(8, 1, 100, true);

그게 다야.

Question 11

1에서 100까지의 숫자를 섞는 것이 올바른 기본 전략이지만 8 개의 섞인 숫자 만 필요한 경우 100 개의 숫자를 모두 섞을 필요가 없습니다.

Javascript를 잘 모르지만 100 개의 null 배열을 빠르게 생성하는 것이 쉽다고 생각합니다. 그런 다음 8 라운드 동안 배열의 n 번째 요소 (0에서 시작하는 n)를 n + 1부터 99까지 임의로 선택한 요소로 바꿉니다. 물론 아직 채워지지 않은 요소는 해당 요소가 실제로 원래 인덱스에 1을 더한 값이므로 고려하기가 쉽습니다. 8 라운드를 완료하면 배열의 처음 8 개 요소에 8 개의 셔플 된 숫자가 있습니다.

Question 12

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

내가 본 다른 답변보다 짧음

Question 13

The Machine Charmer와 동일한 순열 알고리즘이지만 프로토 타입 구현입니다. 많은 수의 선택에 더 적합합니다. 용도 JS 1.7 destructuring 할당이 가능한 경우.

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

Question 14

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

Question 15

가장 좋은 초기 답변은 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));

Question 16

여기에 내가 함께 만든 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);

스 니펫 확장

Question 17

어떻게 사용에 대한 해시 테이블로 개체 속성을 ? 이렇게하면 가장 좋은 시나리오는 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));

그런 다음 Object.keys (obj) 가 ECMAScript 5 기능이므로 위의 내용은 현재 인터넷에서 거의 쓸모가 없다는 것을 알았습니다. 이와 같은 키 기능을 추가하여 ECMAScript 3과 호환되도록 만들었 기 때문에 두려워하지 마십시오.

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

Question 18

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

Question 19

더 고유 한 경우 배열 (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]

Question 20

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는 여전히 맨 위에있는 버전을 사용할 수 있습니다.

추신 : 위키에 대한 업데이트를 제안하려고했지만 거부되었습니다. 나는 여전히 다른 사람들에게 유용 할 것이라고 생각합니다.

Question 21

이것은 내 개인적인 해결책입니다.

<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 사이)을 무작위로 생성 한 다음 경고 상자를 사용하여 표시합니다.

Question 22

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 개 항목을 찾는 것이 전체 배열을 정렬하는 것보다 저렴합니다.

여기에서 정렬 알고리즘이이 알고리즘에 영향을 미친다는 점에 유의해야합니다. 사용 된 정렬 알고리즘이 안정적인 경우 더 작은 숫자를 선호하는 약간의 편향이 있습니다. 이상적으로는 정렬 알고리즘이 불안정하고 안정성 (또는 불안정성)쪽으로 치우 치지 않아 완벽하게 균일 한 확률 분포를 가진 답을 생성하는 것이 좋습니다.

Question 23

최대 20 자리 고유 난수 생성을 처리 할 수 있습니다.

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

jsFiddle

Question 24

이 솔루션은 해시가 배열에 있는지 확인하는 것보다 훨씬 더 성능이 뛰어난 O (1)를 사용합니다. 추가 안전 검사도 있습니다. 도움이되기를 바랍니다.

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

Question 25

이것을 생성기로 구현하면 작업하기가 매우 좋습니다. 이 구현은 전체 입력 배열을 먼저 셔플해야하는 구현과 다릅니다.

이 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배열 입력 변이로 인해 더 이상 순수한 함수가 아니지만 특정 상황 (위에서 설명)에서는 더 의미가있을 수 있습니다.

배열을 반환하는 함수 대신 생성기를 선택한 또 다른 이유는 특정 조건까지 샘플링을 계속할 수 있기 때문입니다.

1,000,000 개의 난수 목록에서 첫 번째 소수를 원할 것입니다.

"몇 개를 샘플링해야합니까?" – 당신은 지정할 필요가 없습니다
"먼저 모든 소수를 찾은 다음 임의의 소수를 선택해야합니까?" -아니.

생성기로 작업하고 있기 때문에이 작업은 간단합니다.

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

이것은 한 번에 하나의 난수를 연속적으로 샘플링 x하고 소수인지 확인한 다음 반환 x됩니다. 소수를 찾기 전에 숫자 목록이 소진되면을 NaN반환합니다.

노트 :

이 답변 은 원래이 질문의 중복으로 마감 된 다른 질문에 공유되었습니다. 여기에 제공된 다른 솔루션과 매우 다르기 때문에 여기에서도 공유하기로 결정했습니다.

Question 26

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
}

Question 27

a를 사용하는 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))

스 니펫 확장

Question 28

이것은 Fisher Yates / Durstenfeld Shuffle 의 구현 이지만 실제로 배열을 생성하지 않으므로 사용 가능한 요소 수에 비해 선택 크기가 작은 경우 필요한 공간 복잡성이나 메모리가 줄어 듭니다.

100에서 8 개의 숫자를 선택하기 위해 100 개의 요소로 구성된 배열을 만들 필요가 없습니다.

어레이가 생성되었다고 가정하면,

array (100) 끝에서 난수 (rnd 에서 1부터 100까지 )를
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)));

스 니펫 확장

Question 29

다음은 중복없이 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)

Question 30

다음과 같이 하나의 라이너로도 할 수 있습니다.

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