Generate unique random numbers between 1 and 100

Question

How can I generate some unique random numbers between 1 and 100 using JavaScript

User · Answer

Here is an example of random 5 numbers taken from a range of 0 to 100  both 0 and 100 included  with no duplication  let finals       const count   5     Considering 5 numbers const max   100   for let i   0  i  lt  max  i       const rand   Math round Math random     max      finals includes rand   amp  amp  finals push rand     finals   finals slice 0  count

User · Answer

var bombout 0  var checkArr     var arr     while arr length  lt  8  amp  amp  bombout lt 100     bombout      var randomNumber Math ceil Math random   100     if typeof checkArr randomNumber      undefined        checkArr randomNumber  1      arr push randomNumber              untested - hence bombout

User · Answer

function getUniqueRandomNos         var indexedArrayOfRandomNo           for  var i   0  i  lt  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  lt  8  i              uniqueRandNoArray push indexedArrayOfRandomNo i  0              return uniqueRandNoArray      I think this method is different from methods given in most of the answers  so I thought I might add an answer here  though the question was asked 4 years ago     We generate 100 random numbers  and tag each of them with numbers from 1 to 100  Then we sort these tagged random numbers  and the tags get shuffled randomly  Alternatively  as needed in this question  one could do away with just finding top 8 of the tagged random numbers  Finding top 8 items is cheaper than sorting the whole array   One must note here  that the sorting algorithm influences this algorithm  If the sorting algorithm used is stable  there is slight bias in favor of smaller numbers  Ideally  we would want the sorting algorithm to be unstable and not even biased towards stability  or instability  to produce an answer with perfectly uniform probability distribution

User · Answer

You can also do it with a one liner like this         add  set    gt  add set  add    set  add    gt  set size  lt  8   add set add Math floor Math random   100    1   add    set  new Set

User · Answer

This solution uses the hash which is much more performant O 1  than checking if the resides in the array  It has extra safe checks too  Hope it helps   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  gt   maxRange - minRange    throw new Error  Cannot generate unique array  Array length too high      while numberOfItemsInArray  lt  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   lt  lt  0      if   hash randomNumber           hash randomNumber    true       array push randomNumber        numberOfItemsInArray               return array   document write uniqueArray 1  100  8

User · Answer

The above techniques are good if you want to avoid a library  but depending if you would be alright with a library  I would suggest checking out Chance for generating random stuff in JavaScript   Specifically to solve your question  using Chance it s as easy as    x000D   x000D     One line  x000D  var uniques   chance unique chance natural  8   min  1  max  100    x000D   x000D     Print it out to the document for this snippet so we can see it in action x000D  document write JSON stringify uniques    x000D   lt script src  http   chancejs com chance min js  gt  lt  script gt  x000D   x000D   x000D    Disclaimer  as the author of Chance  I am a bit biased

User · Answer

For example  To generate 8 unique random numbers and store them to an array  you can simply do this    x000D   x000D  var arr       x000D  while arr length  lt  8   x000D      var r   Math floor Math random     100    1  x000D      if arr indexOf r      -1  arr push r   x000D    x000D  console log arr   x000D   x000D   x000D

User · Answer

Modern JS Solution using Set  and average case O n     x000D   x000D  const nums   new Set    x000D  while nums size     8    x000D    nums add Math floor Math random     100    1   x000D    x000D   x000D  console log     nums    x000D   x000D   x000D

User · Answer

Shuffling the numbers from 1 to 100 is the right basic strategy  but if you need only 8 shuffled numbers  there s no need to shuffle all 100 numbers   I don t know Javascript very well  but I believe it s easy to create an array of 100 nulls quickly   Then  for 8 rounds  you swap the n th element of the array  n starting at 0  with a randomly selected element from n 1 through 99   Of course  any elements not populated yet mean that the element would really have been the original index plus 1  so that s trivial to factor in   When you re done with the 8 rounds  the first 8 elements of your array will have your 8 shuffled numbers

User · Answer

var arr      while arr length  lt  8     var randomnumber Math ceil Math random   100    if arr indexOf randomnumber      -1  arr push randomnumber       document write arr     shorter than other answers I ve seen

User · Answer

This is a very generic function I have written to generate random unique non-unique integers for an array  Assume the last parameter to be true in this scenario for this answer      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  lt  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  lt  len  i                      toReturn push Math floor Math random       max - min    min                                      return toReturn          Here the  tempObj  is a very useful obj since every random number generated will directly check in this tempObj if that key already exists  if not  then we reduce the i by one since we need 1 extra run since the current random number already exists   In your case  run the following   arrayRandom 8  1  100  true     That s all

User · Answer

I would do this   function randomInt min  max        return Math round min   Math random    max-min      var index       numbers       for  var i 0  i lt 8    i        var number      do           number   randomInt 1  100         while  index hasOwnProperty     number        index     number    true      numbers push number     delete index

User · Answer

for arrays with holes like this   2  4  6 7    because my problem was to fill these holes  So I modified it as per my need     the following modified solution worked for me     var arr     2  4  6 7       example while arr length  lt  9     var randomnumber Math floor Math random   9 1     var found false    for var i 0 i lt arr length i         if arr i   randomnumber  found true break          if  found      for k 0 k lt 9 k         if  arr k     if it s empty    MODIFICATION        arr k  randomnumber  break       alert arr     outputs on the screen

User · Answer

if you need more unique you must generate a array 1  100    var arr     function generateRandoms    for var i 1 i lt  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 lt n i    resultArr push extractUniqueRandom        return resultArr      above code is  faster  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

User · Answer

Implementing this as a generator makes it pretty nice to work with  Note  this implementation differs from ones that require the entire input array to be shuffled first       This sample function works lazily  giving you 1 random item per iteration up to N items you ask for  This is nice because if you just want 3 items from a list of 1000  you don t have to touch all 1000 items first     x000D   x000D     sample    Integer - gt   a  - gt   a  x000D  const sample   n   gt  function   xs    x000D    let ys   xs slice 0   x000D    let len   xs length  x000D    while  n  gt  0  amp  amp  len  gt  0    x000D      let i    Math random     len   gt  gt  0  x000D      yield ys splice i 1  0   x000D      n--  len--  x000D      x000D    x000D   x000D     example inputs x000D  let items     a    b    c    d    e    f    g    x000D  let numbers    0  1  2  3  4  5  6  7  8  9   x000D   x000D     get 3 random items x000D  for  let i of sample 3   items   x000D    console log i      f g c x000D   x000D     partial application x000D  const lotto   sample 3   x000D  for  let i of lotto numbers   x000D    console log i      3 8 7 x000D   x000D     shuffle an array x000D  const shuffle   xs   gt  Array from sample  Infinity   xs   x000D  console log shuffle items       b c g f d e a  x000D   x000D   x000D    I chose to implement sample in a way that does not mutate the input array  but you could easily argue that a mutating implementation is favourable   For example  the shuffle function might wish to mutate the original input array  Or you might wish to sample from the same input at various times  updating the input each time    x000D   x000D     sample    Integer - gt   a  - gt   a  x000D  const sample   n   gt  function   xs    x000D    let len   xs length  x000D    while  n  gt  0  amp  amp  len  gt  0    x000D      let i    Math random     len   gt  gt  0  x000D      yield xs splice i 1  0   x000D      n--  len--  x000D      x000D    x000D   x000D     deal     Card  - gt   Card  x000D  const deal   xs   gt  Array from sample  2   xs    x000D   x000D     setup a deck of cards  13 in this case  x000D     cards     Card  x000D  let cards    A234567890JQK  split      x000D   x000D     deal 6 players 2 cards each x000D     players      Card   x000D  let players   Array from Array 6      gt  deal cards   x000D   x000D  console log players   x000D      K  J    6  0    2  8    Q  7    5  4    9  A  x000D   x000D      cards  has been mutated  only 1 card remains in the deck x000D  console log cards   x000D      3  x000D   x000D   x000D    sample is no longer a pure function because of the array input mutation  but in certain circumstances  demonstrated above  it might make more sense     Another reason I chose a generator instead of a function that just returns an array is because you may want to continue sampling until some specific condition   Perhaps I want the first prime number from a list of 1 000 000 random numbers     How many should I sample       you don t have to specify  Do I have to find all the primes first and then select a random prime       Nope    Because we re working with a generator  this task is trivial  const randomPrimeNumber   listOfNumbers   gt      for  let x of sample Infinity   listOfNumbers         if  isPrime x         return x        return NaN      This will continuously sample 1 random number at a time  x  check if it s prime  then return x if it is  If the list of numbers is exhausted before a prime is found  NaN is returned     Note   This answer was originally shared on another question that was closed as a duplicate of this one  Because it s very different from the other solutions provided here  I ve decided to share it here as well

User · Answer

Here is my ES6 version I cobbled together  I m sure it can be a little more consolidated    x000D   x000D  function randomArray i  min  max    x000D    min   Math ceil min   x000D    max   Math floor max   x000D     x000D    let arr   Array from  length  i        gt  Math floor Math random     max - min     min   x000D     x000D    return arr sort    x000D     x000D    x000D   let uniqueItems       new Set randomArray 8  0  100    x000D   console log uniqueItems   x000D   x000D   x000D

User · Answer

getRandom  min  max      return Math floor Math random      max - min     min    getNRandom  min  max  n      const numbers        if  min  gt  max        return new Error  Max is gt min          if  min     max        return  min         if   max - min   gt   n        while  numbers length  lt  n          let rand   this getRandom min  max   1        if  numbers indexOf rand      -1            numbers push rand                       if   max - min   lt  n        for  let i   min  i  lt   max  i            numbers push i              return numbers

User · Answer

This is a  implementation of  Fisher Yates Durstenfeld Shuffle  but without actual creation of a array thus reducing space complexity or memory needed  when the pick size is small compared to the number of elements available   To pick 8 numbers from 100  it is not necessary to create a  array of 100 elements   Assuming a array is created    From the end of array 100   get random number rnd  from 1 to 100     Swap 100 and the  random number rnd     Repeat step 1  with array 99    If a array is not created  A hashMap may be used to remember the actual swapped positions  When the second random number  generated is equal to the one of the previously generated numbers  the map provides the current value in that position rather than the actual value    x000D   x000D  const getRandom     start  end    gt    x000D    return Math floor Math random      end - start   1     start  x000D     x000D  const getRealValue     map  rnd    gt    x000D    if  map has rnd     x000D      return getRealValue  map  map get rnd    x000D      else   x000D      return rnd  x000D      x000D     x000D  const getRandomNumbers    n  start  end    gt    x000D    const out   new Map    x000D    while  n--    x000D      const rnd   getRandom  start  end--   x000D      out set getRealValue  out  rnd   end   1   x000D      x000D    return     out keys     x000D     x000D   x000D  console info getRandomNumbers 8  1  100    x000D  console info getRandomNumbers 8  1  Math pow 10  12     x000D  console info getRandomNumbers 800000  1  Math pow 10  15     x000D   x000D   x000D

User · Answer

Same permutation algorithm as The Machine Charmer  but with a prototyped implementation  Better suited to large number of picks  Uses js 1 7 destructuring assignment if available      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 gt 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  gt   min  a push i--       return a shuffle   slice 0 n      pick 8 1 100     Edit  An other proposition  better suited to small number of picks  based on belugabob s answer  To guarantee uniqueness  we remove the picked numbers from the array      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  gt   min  a push i--       return a pick n      pick 8 1 100

User · Answer

This can handle generating upto 20 digit UNIQUE random number  JS   var generatedNumbers            function generateRandomNumber precision       input -- gt  number precision in integer          if  precision  lt   20                var randomNum   Math round Math random   toFixed precision    Math pow 10  precision                if  generatedNumbers indexOf randomNum   gt  -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

User · Answer

This is my personal solution     lt script gt   var i  k  var numbers   new Array    k   Math floor  Math random   8    numbers 0  k      for  var j 1 j lt 8 j             k   Math floor  Math random   8    i 0  while  i  lt  numbers length   if  numbers i     k       k   Math floor  Math random   8        i 0   else  i       numbers j  k            for  var j 0 j lt 8 j     alert  numbers j           lt  script gt    It randomly generates 8 unique array values  between 0 and 7   then displays them using an alert box

User · Answer

Another approach is to generate an 100 items array with ascending numbers and sort it randomly  This leads actually to a really short and  in my opinion  simple snippet    x000D   x000D  const numbers   Array 100  fill   map     index    gt  index   1   x000D  numbers sort      gt  Math random   - 0 5   x000D  console log numbers slice 0  8    x000D   x000D   x000D

User · Answer

Using a Set is your fastest option   Here is a generic function for getting a unique random that uses a callback generator   Now it s fast and reusable    x000D   x000D     Get a unique  anything  x000D  let unique   new Set   x000D   x000D  function getUnique generator    x000D    let number   generator   x000D    while   unique add number     x000D      number   generator   x000D      x000D    return number  x000D    x000D   x000D     The generator   Return anything  not just numbers  x000D  const between 1 100        gt  1   Math floor Math random     100  x000D   x000D     Test it x000D  for  var i   0  i  lt  8  i      x000D    const aNumber   getUnique between 1 100  x000D    x000D     Dump the  stored numbers  x000D  console log Array from unique   x000D   x000D   x000D

User · Answer

Generate permutation of 100 numbers and then choose serially   Use Knuth Shuffle aka the Fisher-Yates shuffle  Algorithm   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            CODE COPIED FROM LINK   EDIT   Improved code   function fisherYates myArray nb picks        for  i   myArray length-1  i  gt  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       Potential problem   Suppose we have array of 100 numbers  e g   1 2 3   100   and we stop swapping after 8 swaps  then most of the times array will look like  1 2 3 76 5 6 7 8    numbers here will be shuffled    10    Because every number will be swapped with probability 1 100 so  prob  of swapping first 8 numbers is 8 100 whereas prob  of swapping other 92 is 92 100   But if we run algorithm for full array then we are sure  almost every entry is swapped   Otherwise we face a question   which 8 numbers to choose

User · Answer

To avoid any long and unreliable shuffles  I d do the following      Generate an array that contains the number between 1 and 100  in order  Generate a random number between 1 and 100 Look up the number at this index in the array and store in your results Remove the elemnt from the array  making it one shorter Repeat from step 2  but use 99 as the upper limit of the random number Repeat from step 2  but use 98 as the upper limit of the random number Repeat from step 2  but use 97 as the upper limit of the random number Repeat from step 2  but use 96 as the upper limit of the random number Repeat from step 2  but use 95 as the upper limit of the random number Repeat from step 2  but use 94 as the upper limit of the random number Repeat from step 2  but use 93 as the upper limit of the random number   Voila - no repeated numbers   I may post some actual code later  if anybody is interested   Edit  It s probably the competitive streak in me but  having seen the post by  Alsciende  I couldn t resist posting the code that I promised    lt  DOCTYPE HTML PUBLIC  -  W3C  DTD HTML 3 2 Final  EN  gt   lt html gt   lt head gt   lt title gt 8 unique random number between 1 and 100 lt  title gt   lt script type  text javascript  language  Javascript  gt      function pick n  min  max           var values       i   max          while i  gt   min  values push i--           var results               var maxIndex   max          for i 1  i  lt   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         lt  script gt   lt  head gt    lt body gt       lt h1 gt 8 unique random number between 1 and 100 lt  h1 gt       lt p gt  lt button onclick  go    gt Click me lt  button gt  to start generating numbers  lt  p gt       lt p gt When the numbers appear  click OK to generate another set  or Cancel to stop  lt  p gt   lt  body gt

User · Answer

Adding another better version of same code  accepted answer  with JavaScript 1 6 indexOf function  Do not need to loop thru whole array every time you are checking the duplicate   var arr      while arr length  lt  8     var randomnumber Math ceil Math random   100    var found false      if arr indexOf randomnumber   gt  -1  found true     if  found arr arr length  randomnumber      Older version of Javascript can still use the version at top  PS  Tried suggesting an update to the wiki but it was rejected  I still think it may be useful for others

User · Answer

How about using object properties as a hash table  This way your best scenario is to only randomize 8 times  It would only be effective if you want a small part of the range of numbers  It s also much less memory intensive than Fisher-Yates because you don t have to allocate space for an array   var ht     i rands 8  while   i gt 0    keys ht  length lt rands  ht Math ceil Math random   100   i--  alert keys ht      I then found out that Object keys obj  is an ECMAScript 5 feature so the above is pretty much useless on the internets right now  Fear not  because I made it ECMAScript 3 compatible by adding a keys function like this   if  typeof keys     undefined         var keys   function obj           props         for  k in ht  if  ht hasOwnProperty k   props push k       return props

User · Answer

Populate an array with the numbers 1 through 100  Shuffle it  Take the first 8 elements of the resulting array

User · Answer

The best earlier answer is the answer by sje397  You will get as good random numbers as you can get  as quick as possible   My solution is very similar to his solution  However  sometimes you want the random numbers in random order  and that is why I decided to post an answer  In addition  I provide a general function   function selectKOutOfN k  n      if  k gt n  throw  k gt n     var selection         var sorted         for  var i   0  i  lt  k  i          var rand   Math floor Math random    n - i        for  var j   0  j  lt  i  j            if  sorted j  lt  rand          rand          else         break            selection push rand       sorted splice j  0  rand         return selection     alert selectKOutOfN 8  100

[javascript] Generate unique random numbers between 1 and 100

Examples related to javascript

Examples related to random

Examples related to integer

Examples related to numbers