var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;

Matematyka.losowe()

Z Mozilla Dokumentacja sieci programistów:

// Returns a random integer between min (include) and max (include)

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

Przydatne przykłady:

// 0 - 10
Math.floor(Math.random() * 11);

// 1 - 10
Math.floor(Math.random() * 10) + 1;

// 5 - 20
Math.floor(Math.random() * 16) + 5;

// -10 - (-2)
Math.floor(Math.random() * 9) - 10;

function getRandomizer(bottom, top) {
    return function() {
        return Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom;
    }
}

Użycie:

var rollDie = getRandomizer( 1, 6 );

var results = ""
for ( var i = 0; i<1000; i++ ) {
    results += rollDie() + " ";    //make a string filled with 1000 random numbers in the range 1-6.
}

Podział:

Zwracamy funkcję (zapożyczoną z programowania funkcyjnego), która po wywołaniu zwróci losową liczbę całkowitą między wartościami bottom i top, włącznie. Mówimy "inclusive", ponieważ chcemy włączyć zarówno dół, jak i górę w zakresie liczb, które mogą być zwrócone. W ten sposób getRandomizer( 1, 6 ) zwróci albo 1, 2, 3, 4, 5, do 6.

(dół to dolna liczba, Góra to większa liczba)

Math.random() * ( 1 + top - bottom )

Math.random() zwraca a losowe podwójne między 0 a 1, a jeśli pomnożymy je przez jeden plus różnicę między top i bottom, otrzymamy podwójne gdzieś pomiędzy 0 i 1+b-a.

Math.floor( Math.random() * ( 1 + top - bottom ) )

Math.floor Zaokrągla liczbę do najbliższej liczby całkowitej. Mamy więc teraz wszystkie liczby całkowite pomiędzy 0 i top-bottom. 1 wygląda na mylące, ale musi tam być, ponieważ zawsze zaokrąglamy w dół, więc najwyższa liczba nigdy nie zostanie osiągnięta bez niej. Losowy dziesiętny, który generujemy musi być w zakresie 0 do (1+top-bottom) więc możemy zaokrąglić w dół i uzyskać Int w zakresie 0 do top-bottom

Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom

Kod w poprzednim przykładzie dał nam liczbę całkowitą w zakresie 0 i top-bottom, więc teraz wystarczy dodać bottom do tego wyniku, aby uzyskać liczbę całkowitą w zakresie bottom i top włącznie. : D

UWAGA: Jeśli wprowadzisz Nie-całkowitą wartość lub większą liczbę najpierw otrzymasz niepożądane zachowanie, ale jeśli ktoś tego nie zażąda, Nie będę zagłębiał się w argument sprawdzanie kodu jako jego raczej dalekie od intencji pierwotnego pytania.

Zwraca losową liczbę z zakresu od 1 do 10:

Math.floor((Math.random()*10) + 1); 

Zwraca losową liczbę z zakresu od 1 do 100:

Math.floor((Math.random()*100) + 1)

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

Alternatywa jeśli używasz podkreślam.js możesz użyć

_.random(min, max)

Pozostałe odpowiedzi nie odpowiadają całkowicie rozsądnym parametrom 0 i 1. Zamiast tego powinieneś użyć round zamiast z ceil lub floor:

function randomNumber(minimum, maximum){
    return Math.round( Math.random() * (maximum - minimum) + minimum);
}

console.log(randomNumber(0,1));  # 0 1 1 0 1 0
console.log(randomNumber(5,6));  # 5 6 6 5 5 6
console.log(randomNumber(3,-1)); # 1 3 1 -1 -1 -1

Po wygenerowaniu liczby losowej za pomocą programu komputerowego, nadal uważa się ją za liczbę losową, jeśli wybrana liczba jest częścią lub PEŁNĄ z początkowej. Ale jeśli została zmieniona, to matematycy nie akceptują jej jako liczby losowej i mogą ją nazwać liczbą stronniczą. ale jeśli tworzysz program do prostego zadania, nie będzie to brane pod uwagę. ale jeśli tworzysz program do generowania losowej liczby dla wartościowych rzeczy, takich jak loteria program lub gra hazardowa, wtedy twój program zostanie odrzucony przez kierownictwo, jeśli nie rozważysz powyższego przypadku.

Wygeneruj losową liczbę za pomocą Math.random().(say this 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.

Jeśli wiesz, jak odczytać tabelę liczb losowych, aby wybrać liczbę losową, wiesz, że powyższy proces (mnożenie przez 1, 10, 100 i tak dalej) nie narusza tego, o którym wspomniałem na początku.(Ponieważ zmienia tylko miejsce po przecinku.)

Przestudiuj poniższy przykład i rozwiń go do swoich potrzeb.

Jeśli potrzebujesz próbki [0,9] to piętro n*10 jest twoją odpowiedzią, a jeśli potrzebujesz [0,99] to piętro n*100 jest twoją odpowiedzią i tak dalej.

Teraz pozwól wejść w swoją rolę:

Poprosiłeś o liczby w określonym zakresie. (W tym przypadku jesteś stronniczy wśród tego zakresu. - Biorąc liczbę z [1,6] przez roll a die, to jesteś stronniczy w [1,6], ale nadal jest to losowe wtedy i tylko wtedy, gdy die jest bezstronny.)

Więc rozważ swój zakres = = >[78, 247] liczba elementów zakresu = 247 - 78 + 1 = 170; (ponieważ obie granice są włączone.

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

Uwaga: w pierwszej metodzie najpierw stworzyłem tablicę zawierającą potrzebne liczby, a następnie losowo umieściłem je w innej tablicy. W metodzie drugiej Generuj LOSOWO LICZBY i sprawdź, czy znajdują się one w zakresie, którego potrzebujesz. Następnie umieścić go w tablicy. Tutaj wygenerowałem dwie losowe liczby i użyłem ich sumy, aby zmaksymalizować szybkość programu poprzez zminimalizowanie wskaźnika awarii, który uzyskuje użyteczną liczbę. Jednak dodawanie wygenerowanych liczb również da trochę biassness. Polecam więc moją pierwszą metodę generowania liczb losowych w określonym zakresie.

W obu metodach konsola wyświetli wynik.(Naciśnij klawisz f12 w Chrome, aby otworzyć konsolę)

Dla losowej liczby całkowitej z zakresem, spróbuj:

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

Oto Implementacja klasy losowej ms DotNet w javascript -

var Random = (function () {
function Random(Seed) {
    if (!Seed) {
        Seed = this.milliseconds();
    }
    this.SeedArray = [];
    for (var i = 0; i < 56; i++)
        this.SeedArray.push(0);
    var num = (Seed == -2147483648) ? 2147483647 : Math.abs(Seed);
    var num2 = 161803398 - num;
    this.SeedArray[55] = num2;
    var num3 = 1;
    for (var i_1 = 1; i_1 < 55; i_1++) {
        var num4 = 21 * i_1 % 55;
        this.SeedArray[num4] = num3;
        num3 = num2 - num3;
        if (num3 < 0) {
            num3 += 2147483647;
        }
        num2 = this.SeedArray[num4];
    }
    for (var j = 1; j < 5; j++) {
        for (var k = 1; k < 56; k++) {
            this.SeedArray[k] -= this.SeedArray[1 + (k + 30) % 55];
            if (this.SeedArray[k] < 0) {
                this.SeedArray[k] += 2147483647;
            }
        }
    }
    this.inext = 0;
    this.inextp = 21;
    Seed = 1;
}
Random.prototype.milliseconds = function () {
    var str = new Date().valueOf().toString();
    return parseInt(str.substr(str.length - 6));
};
Random.prototype.InternalSample = function () {
    var num = this.inext;
    var num2 = this.inextp;
    if (++num >= 56) {
        num = 1;
    }
    if (++num2 >= 56) {
        num2 = 1;
    }
    var num3 = this.SeedArray[num] - this.SeedArray[num2];
    if (num3 == 2147483647) {
        num3--;
    }
    if (num3 < 0) {
        num3 += 2147483647;
    }
    this.SeedArray[num] = num3;
    this.inext = num;
    this.inextp = num2;
    return num3;
};
Random.prototype.Sample = function () {
    return this.InternalSample() * 4.6566128752457969E-10;
};
Random.prototype.GetSampleForLargeRange = function () {
    var num = this.InternalSample();
    var flag = this.InternalSample() % 2 == 0;
    if (flag) {
        num = -num;
    }
    var num2 = num;
    num2 += 2147483646.0;
    return num2 / 4294967293.0;
};
Random.prototype.Next = function (minValue, maxValue) {
    if (!minValue && !maxValue)
        return this.InternalSample();
    var num = maxValue - minValue;
    if (num <= 2147483647) {
        return parseInt((this.Sample() * num + minValue).toFixed(0));
    }
    return this.GetSampleForLargeRange() * num + minValue;
};
Random.prototype.NextDouble = function () {
    return this.Sample();
};
Random.prototype.NextBytes = function (buffer) {
    for (var i = 0; i < buffer.length; i++) {
        buffer[i] = this.InternalSample() % 256;
    }
};
return Random;
}());

Użycie:

        var r = new Random();
        var nextInt = r.Next(1, 100); //returns an integer between range
        var nextDbl = r.NextDouble(); //returns a random decimal

Jeśli potrzebujesz zmiennej od 0 do max możesz użyć:

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

Aby otrzymać losową liczbę powiedz od 1 do 6, najpierw wykonaj:

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

To mnoży losową liczbę przez 6, a następnie dodaje do niej 0,5. Następnie zaokrąglić liczbę do dodatniej liczby całkowitej, wykonując:

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

Zaokrąglamy liczbę do najbliższej liczby całkowitej.

Lub aby było to bardziej zrozumiałe zrób to:

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

Ogólnie rzecz biorąc, kod do zrobienia tego przy użyciu zmiennych to:

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

Powodem odebrania 0.5 od wartości minimalnej jest to, że użycie wartości minimalnej sam pozwoli ci uzyskać liczbę całkowitą, która była o jeden więcej niż maksymalna wartość. Odejmując 0,5 od wartości minimalnej zasadniczo uniemożliwiasz zaokrąglenie wartości maksymalnej.

Mam nadzieję, że to pomoże.

Za pomocą poniższego kodu można wygenerować tablicę liczb losowych, bez powtarzania, w danym zakresie.

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

Losowa liczba całkowita między najniższą a najwyższą:

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

Wiem, że na to pytanie już odpowiedziałam, ale moja odpowiedź może komuś pomóc.

Znalazłem tą prostą metodę na W3Schools:

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

Oto, czego używam do generowania losowych liczb.

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

Wykonujemy high++ PonieważMath.random() generuje liczbę losową z zakresu od 0 (włącznie) do 1(wyłączności), która jest wykluczona, oznacza to, że musimy zwiększyć wartość o jeden przed wykonaniem dowolnej matematyki. Następnie odejmujemy low od high, dając nam najwyższą liczbę do wygenerowania-low, następnie + low, przywracając high z powrotem do normy, a najniższą liczbę co najmniej low. następnie zwracamy liczbę wynikową

random(7,3) could return 3,4,5,6, or 7

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

Uint8array Utwórz tablicę wypełnioną liczbą do 3 cyfr, która będzie maksymalnie 999. Ten kod jest bardzo krótki.

To jest moje podejście do liczby losowej w zakresie, ponieważ chciałem uzyskać liczbę losową w zakresie od bazy do wykładnika. np. baza = 10, wykładnik = 2, daje liczbę losową od 0 do 100, najlepiej, i tak dalej.

Jeśli to pomaga go używać, oto jest:

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

Hey Guys I have created a javascript function like Math.random() za pomocą którego możemy wygenerować liczbę losową o dowolnej określonej długości . Bez użycia matematyki.funkcja losowa {[3] }.

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

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

Aby przetestować tę funkcję i jej odmiany, zapisz poniższy HTML / JavaScript do pliku i Otwórz za pomocą przeglądarki. Kod wygeneruje Wykres pokazujący rozkład miliona wywołań funkcji. Kod rejestruje również przypadki krawędzi, więc jeśli funkcja generuje wartość większą niż max, lub mniejszą niż min, you.will.know.about.it.

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

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

To może obsłużyć generowanie do 20 cyfr unikalnej liczby losowej

JS

var generatedNumbers = [];

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

/* Napisz funkcję randUpTo, która przyjmuje liczbę i zwraca losowa liczba całkowita między 0 a tą liczbą? */

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

/* Napisz funkcję randBetween, która przyjmuje dwie liczby reprezentujący zakres i zwraca losową liczbę całkowitą pomiędzy tymi dwoma liczby. */

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

/* Napisz funkcję randFromTill, która przyjmuje dwie liczby reprezentujący zakres i zwraca liczbę losową między min (włącznie) i max (exclusive). */

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

/* Napisz funkcję randFromTo, która przyjmuje dwie liczby reprezentujący zakres i zwraca losową liczbę całkowitą między min (włącznie) i max (włącznie) */

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

Alternatywne Rozwiązanie:-

let makeGuess = function(guess){
    let min = 1;
    let max = 5;   
    let randomNumber = Math.floor(Math.random() * (max - min + 1)) + min

    return guess === randomNumber;

}
console.log(makeGuess(1));

Zastanawiałem się, jak dystrybucja po wystarczającej ilości uruchomień będzie dla takiej funkcji randomizera.

A także, aby sprawdzić, czy ta dystrybucja będzie mniej więcej taka sama w różnych przeglądarkach.

Więc tutaj jest fragment do uruchomienia. Liczby można zmienić przed naciśnięciem przycisku.

function getRandomNumberInRange(Min, Max) {
    return Math.floor(Math.random() * (Max - Min + 1)) + Min;
}

function printDictAsTable(dict){
   let htmlstr = "<table border=1><tr><th>Number</th><th>Count</th></tr>";
   
   let sortedKeys = Object.keys(dict).sort(function(a,b){return a-b});

   for (let i=0; i<sortedKeys.length; i++) {
     let key = sortedKeys[i];
     htmlstr += "<tr><td>"+ key +" </td><td>" + dict[key] + " </td></tr>";
   }
   htmlstr += "</table>";
   document.getElementById("tableContainer").innerHTML = htmlstr;
}

function loopRandomAndPrint(){
    let min = Number(document.getElementById("randomMinLimit").value);
    let max = Number(document.getElementById("randomMaxLimit").value);
    if (max < min){let temp = max; max = min; min = temp;}
    let loopTotal = Number(document.getElementById("loopLimit").value);
    let dict = {};
    
    for(i = min; i <= max; ++i){
        dict[i] = 0;
    }

    for(i = 0; i < loopTotal; i++){
        let num = getRandomNumberInRange(min, max);
        dict[num] = dict[num] + 1;
    }
    
    printDictAsTable(dict);
}

loopRandomAndPrint();

<div id="topContainer">
<div id="inputAndButton" style="float: left;">
<p>Min  : <input type="number" id="randomMinLimit" value=4></p>
<p>Max  : <input type="number" id="randomMaxLimit" value=8></p>
<p>Loops: <input type="number" id="loopLimit" value=1000></p>
<button type="button" onclick="loopRandomAndPrint()">
Loop random function and show </button>
</div>
<div id="tableContainer" style="float: right;">
</div>
</div>