let cs= (x,y)=>x+(y-x+1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32|0
console.log(cs(4,8))

Antwoord 13

Na het genereren van een willekeurig getal met behulp van een computerprogramma, wordt het nog steeds als een willekeurig getal beschouwd als het gekozen getal een deel of het volledige getal is van het oorspronkelijke getal. Maar als het is veranderd, dan accepteren wiskundigen het niet als een willekeurig getal en kunnen ze het een bevooroordeeld getal noemen.Maar als je een programma ontwikkelt voor een eenvoudige taak, zal dit niet het geval zijn overwegen. Maar als u een programma ontwikkelt om een willekeurig getal te genereren voor waardevolle zaken zoals een loterijprogramma of gokspel, dan zal uw programma door het management worden afgewezen als u geen rekening houdt met het bovenstaande geval.>

Dus voor dat soort mensen, hier is mijn suggestie:

Genereer een willekeurig getal met Math.random().(zeg dit 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.

Als je weet hoe je een tabel met willekeurige getallen moet lezen om een willekeurig getal te kiezen, weet je dat het bovenstaande proces (vermenigvuldigen met 1, 10, 100 enzovoort) niet in strijd is met degene die ik aan het begin noemde. (Omdat het verandert alleen de plaats van de komma.)

Bestudeer het volgende voorbeeld en ontwikkel het naar uw behoeften.

Als u een steekproef [0,9] nodig heeft, dan is een minimum van n*10 uw antwoord en indien nodig [0,99] dan is een minimum van n*100 uw antwoord, enzovoort.

Laat nu uw rol vervullen:

Je hebt gevraagd naar nummers uit een specifiek bereik. (In dit geval ben je bevooroordeeld in dat bereik. – Door een getal van [1,6] te nemen door een dobbelsteen te gooien, ben je bevooroordeeld in [1,6] maar het is nog steeds een willekeurige als en alleen als de dobbelsteen onbevooroordeeld is .)

Dus overweeg uw bereik ==> [78, 247]
aantal elementen van het bereik = 247 – 78 + 1 = 170; (aangezien beide grenzen inclusief zijn.

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

Opmerking: In methode één heb ik eerst een array gemaakt die de getallen bevat die je nodig hebt en deze vervolgens willekeurig in een andere array geplaatst.
Genereer in methode twee willekeurig getallen en controleer of deze binnen het bereik vallen dat u nodig hebt. Zet het dan in een array. Hier heb ik twee willekeurige getallen gegenereerd en in totaal gebruikt om de snelheid van het programma te maximaliseren door het percentage mislukkingen te minimaliseren dat een bruikbaar getal verkrijgt. Het toevoegen van gegenereerde getallen geeft echter ook enige vooringenomenheid. Dus ik zou mijn eerste methode aanbevelen om willekeurige getallen binnen een specifiek bereik te genereren.

In beide methoden geeft uw console het resultaat weer. (Druk op f12 in Chrome om de console te openen)

Antwoord 14

Probeer voor een willekeurig geheel getal met een bereik:

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

Antwoord 15

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

Om deze functie en variaties van deze functie te testen, slaat u de onderstaande HTML/JavaScript op in een bestand en opent u deze met een browser. De code zal een grafiekproduceren die de verdeling van één miljoen functieaanroepen toont. De code registreert ook de randgevallen, dus als de functie een waarde produceert die groter is dan de max, of kleiner dan de min, dan weet je het.

<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">&nbsp;[' + (i + min - 1) + ']:&nbsp;'+array[i]+'</span>&nbsp;&nbsp;');
        }
        document.write('<hr/>');
        </script>
    </head>
    <body>
    </body>
</html>

Antwoord 16

Om een willekeurig getal tussen 1 en 6 te krijgen, doe je eerst:

   0.5 + (Math.random() * ((6 - 1) + 1))

Dit vermenigvuldigt een willekeurig getal met 6 en voegt er vervolgens 0,5 aan toe. Rond het getal vervolgens af op een positief geheel getal door te doen:

   Math.round(0.5 + (Math.random() * ((6 - 1) + 1))

Hiermee rondt u het getal af op het dichtstbijzijnde gehele getal.

Of om het begrijpelijker te maken, doe dit:

   var value = 0.5 + (Math.random() * ((6 - 1) + 1))
    var roll = Math.round(value);
    return roll;

Over het algemeen is de code om dit te doen met behulp van variabelen:

   var value = (Min - 0.5) + (Math.random() * ((Max - Min) + 1))
    var roll = Math.round(value);
    return roll;

De reden om 0,5 van de minimumwaarde af te halen, is dat als u alleen de minimumwaarde gebruikt, u een geheel getal krijgt dat één meer is dan uw maximumwaarde. Door 0,5 van de minimumwaarde af te halen, voorkomt u in feite dat de maximumwaarde naar boven wordt afgerond.

Hopelijk helpt dat.

Antwoord 17

Met de volgende code kun je een reeks willekeurige getallen genereren, zonder herhaling, in een bepaald bereik.

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

Antwoord 18

Ik weet dat deze vraag al is beantwoord, maar mijn antwoord kan iemand helpen.

Ik vond deze eenvoudige methode op W3Schools:

Math.floor((Math.random() * max) + min);

Ik hoop dat dit iemand zou helpen.

Antwoord 19

Willekeurig geheel getal tussen laagste en hoogste:

function randomRange(l,h){
  var range = (h-l);
  var random = Math.floor(Math.random()*range);
  if (random === 0){random+=1;}
  return l+random;
}

Niet de meest elegante oplossing.. maar iets snels.

Antwoord 20

Dit is wat ik gebruik om willekeurige getallen te genereren.

function random(high,low) {
    high++;
    return Math.floor((Math.random())*(high-low))+low;
}

We uitvoeren high++omdat Math.random()genereert een willekeurig getal tussen 0, (inclusief), en 1 (exclusief), betekent dat wij dat is uitgesloten Moet de hoge door één verhogen voordat u een wiskunde uitvoert. We aftrekken dan laag van hoog, waardoor we het hoogste aantal geven om te genereren – laag, dan + laag, waardoor ze hoog naar normaal brengen en het laagste aantal tenminste laag maken. Dan sturen we het resulterende nummer

random(7,3)kan 3,4,5,6, or 7

retourneren

Antwoord 21

Math.random()is snel en geschikt voor vele doeleinden, maar het is niet geschikt als u cryptografisch beveiligde waarden nodig hebt (het is niet beveiligd), of als u gehele getallen van een volledig uniforme onbevooroordeeld hebt of als u gehets nodig heeft Distributie (de vermenigvuldigingsbenadering die in andere antwoorden wordt gebruikt, produceert bepaalde waarden iets vaker dan andere).

In dergelijke gevallen kunnen we crypto.getRandomValues()gebruiken om beveiligde gehele getallen te genereren en alle gegenereerde waarden af ​​te wijzen die we niet uniform in het doelbereik kunnen plaatsen. Dit zal langzamer zijn, maar het zou niet significant moeten zijn, tenzij u extreem grote aantallen waarden genereert.

Overweeg de vooringenomen distributiedistributie, rekening houdend met het geval waarin we een waarde tussen 1 en 5 willen genereren, maar we hebben een willekeurige nummergenerator die waarden oplevert tussen 1 en 16 (een 4-bits waarde). We willen hetzelfde aantal gegenereerde waarden in kaart brengen op elke uitgangswaarde, maar 16 deelt niet gelijkmatig met 5: het laat een rest van 1. dus we moeten 1 van de mogelijke gegenereerde waarden afwijzen en alleen doorgaan Een van de 15 mindere waarden die uniform in ons doelbereik kunnen worden toegewezen. Ons gedrag kan eruit zien als deze pseudocode:

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.

De volgende code gebruikt vergelijkbare logica, maar genereert in plaats daarvan een 32-bits geheel getal, want dat is de grootste algemene integer-maat die kan worden weergegeven door de standaard numbervan Javascript. (Dit kan worden gewijzigd om BigIntS te gebruiken als u een groter bereik nodig hebt.) Ongeacht het gekozen bereik, zal de fractie van gegenereerde waarden die worden afgewezen altijd minder dan 0,5 zijn, dus het verwachte aantal Afwijzingen zullen altijd minder zijn dan 1,0 en meestal dicht bij 0,0; Je hoeft je geen zorgen te maken dat je voor altijd loopt.

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]

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

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

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

function randomRange(min, max) {
   return Math.floor( (Math.random() * (max-min +1) ) + min );
}

maxNum = 8,
minNum = 4
console.log(Math.floor(Math.random() * (maxNum - minNum) + minNum))
console.log(Math.floor(Math.random() * (8 - 4) + 4))

Math.floor((Math.random() * 10) % n)

var randUpTo = function(num) {
    return Math.floor(Math.random() * (num - 1) + 0);
};

var randBetween = function (min, max) {
    return Math.floor(Math.random() * (max - min - 1)) + min;
};

var randFromTill = function (min, max) {
    return Math.random() * (max - min) + min;
};

var randFromTo = function (min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
};

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