Uzyskaj losową liczbę skoncentrowaną na środku

Czy można uzyskać losową liczbę od 1 do 100 i utrzymać wyniki głównie w przedziale 40–60? Chodzi mi o to, że rzadko wychodzi poza ten zakres, ale chcę, aby był głównie w tym zakresie ... Czy jest to możliwe w JavaScript / jQuery?

Teraz używam tylko podstawowego Math.random() * 100 + 1.

Najprostszym sposobem byłoby wygenerowanie dwóch liczb losowych od 0-50 i dodanie ich razem.

Daje to rozkład nastawiony na 50, w ten sam sposób rzucając dwie tendencje kostek w kierunku 7.

W rzeczywistości, używając większej liczby „kostek” (jak sugeruje @Falco) , możesz przybliżyć się do krzywej dzwonowej:

function weightedRandom(max, numDice) {
    var num = 0;
    for (var i = 0; i < numDice; i++) {
        num += Math.random() * (max/numDice);
    }    
    return num;
}

JSFiddle: http://jsfiddle.net/797qhcza/1/

Masz tutaj kilka dobrych odpowiedzi, które dają konkretne rozwiązania; Pozwól, że opiszę ci ogólne rozwiązanie. Problemem jest:

• Mam źródło mniej więcej równomiernie rozmieszczonych liczb losowych od 0 do 1.
• Chciałbym stworzyć sekwencję liczb losowych o innym rozkładzie.

Ogólnym rozwiązaniem tego problemu jest wypracowanie funkcji kwantylowej pożądanego rozkładu, a następnie zastosowanie funkcji kwantyli do wyjścia jednolitego źródła.

Funkcja kwantyl jest odwrotny od całki od żądanej funkcji rozkładu . Funkcja rozkładu to funkcja, w której pole pod częścią krzywej jest równe prawdopodobieństwu, że losowo wybrany element będzie w tej części.

Daję przykład, jak to zrobić tutaj:

http://ericlippert.com/2012/02/21/generating-random-non-uniform-data/

Kod tam jest w C #, ale zasady dotyczą każdego języka; dostosowanie rozwiązania do JavaScript powinno być proste.

Odczytywanie tablic liczb itp. Nie jest wydajne. Powinieneś wziąć mapowanie, które przyjmuje losową liczbę od 0 do 100 i mapuje do rozkładu, którego potrzebujesz. W twoim przypadku możesz wziąć rozkład z największą liczbą wartości w środku zakresu.f(x)=-(1/25)x2+4x

Mógłbym zrobić coś takiego jak ustawienie „szansy”, aby liczba mogła przekroczyć granicę. W tym przykładzie szansa na 20% będzie wynosić 1-100, w przeciwnym razie 40-60:

$(function () {
    $('button').click(function () {
        var outOfBoundsChance = .2;
        var num = 0;
        if (Math.random() <= outOfBoundsChance) {
            num = getRandomInt(1, 100);
        } else {
            num = getRandomInt(40, 60);
        }
        $('#out').text(num);
    });
    
    function getRandomInt(min, max) {
        return Math.floor(Math.random() * (max - min + 1)) + min;
    }
});

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>

<button>Generate</button>
<div id="out"></div>

skrzypce: http://jsfiddle.net/kbv39s9w/

Musiałem rozwiązać ten problem kilka lat temu, a moje rozwiązanie było łatwiejsze niż jakiekolwiek inne odpowiedzi.

Wygenerowałem 3 losy między granicami i uśredniłem je. To przyciąga wynik do środka, ale pozostawia całkowicie możliwość dotarcia do kończyn.

To wygląda głupio, ale można użyć rand dwukrotnie:

var choice = Math.random() * 3;
var result;

if (choice < 2){
    result = Math.random() * 20 + 40; //you have 2/3 chance to go there
}
else {
    result = Math.random() * 100 + 1;
}

Jasne, że to możliwe. Zrób losowy 1-100. Jeśli liczba wynosi <30, wygeneruj liczbę z zakresu 1-100, jeśli nie, wygeneruj ją w zakresie 40-60.

Istnieje wiele różnych sposobów generowania takich liczb losowych. Jednym ze sposobów jest obliczenie sumy wielu równomiernie losowych liczb. Ile liczb losowych zsumujesz i jaki jest ich zasięg, określi, jak będzie wyglądał ostateczny rozkład.

Im więcej liczb zsumujesz, tym bardziej będzie on tendencyjny do środka. Wykorzystanie sumy 1 liczb losowych zostało już zaproponowane w twoim pytaniu, ale jak zauważysz, nie jest tendencyjne w kierunku środka zakresu. Inne odpowiedzi sugerują użycie sumy 2 liczb losowych lub sumy 3 liczb losowych .

Możesz uzyskać jeszcze więcej odchylenia w kierunku środka zakresu, biorąc sumę więcej liczb losowych. W skrajności można przyjąć sumę 99 liczb losowych, z których każda ma wartość 0 lub 1. To byłby rozkład dwumianowy. (Rozkłady dwumianowe można w pewnym sensie postrzegać jako dyskretną wersję rozkładów normalnych). Teoretycznie może to obejmować cały zakres, ale ma tak dużą tendencję do centrum, że nigdy nie należy oczekiwać, że osiągnie punkty końcowe.

Takie podejście oznacza, że ​​możesz dostosować, ile chcesz stronniczości.

Co z użyciem czegoś takiego:

var loops = 10;
var tries = 10;
var div = $("#results").html(random());
function random() {
    var values = "";
    for(var i=0; i < loops; i++) {
        var numTries = tries;
        do {
            var num = Math.floor((Math.random() * 100) + 1);
            numTries--;
        }
        while((num < 40 || num >60) && numTries > 1)
        values += num + "<br/>";
    }
    return values;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
<div id="results"></div>

Sposób, w jaki go kodowałem, pozwala ustawić kilka zmiennych:
pętle = liczba wyników
prób = liczba przypadków, gdy funkcja spróbuje uzyskać liczbę między 40-60, zanim przestanie działać przez pętlę while

Dodano bonus: Używa zrobić do czasu !!! Awesomeness w najlepszym wydaniu

Można napisać funkcję, która mapuje wartości losowych między [0, 1)aby [1, 100]w zależności od wagi. Rozważ ten przykład:

Tutaj wartość jest 0.95odwzorowywana na wartość między [61, 100].
W rzeczywistości mamy .05 / .1 = 0.5, co po mapowaniu [61, 100]daje 81.

Oto funkcja:

/*
 * Function that returns a function that maps random number to value according to map of probability
 */
function createDistributionFunction(data) {
  // cache data + some pre-calculations
  var cache = [];
  var i;
  for (i = 0; i < data.length; i++) {
    cache[i] = {};
    cache[i].valueMin = data[i].values[0];
    cache[i].valueMax = data[i].values[1];
    cache[i].rangeMin = i === 0 ? 0 : cache[i - 1].rangeMax;
    cache[i].rangeMax = cache[i].rangeMin + data[i].weight;
  }
  return function(random) {
    var value;
    for (i = 0; i < cache.length; i++) {
      // this maps random number to the bracket and the value inside that bracket
      if (cache[i].rangeMin <= random && random < cache[i].rangeMax) {
        value = (random - cache[i].rangeMin) / (cache[i].rangeMax - cache[i].rangeMin);
        value *= cache[i].valueMax - cache[i].valueMin + 1;
        value += cache[i].valueMin;
        return Math.floor(value);
      }
    }
  };
}

/*
 * Example usage
 */
var distributionFunction = createDistributionFunction([
  { weight: 0.1, values: [1, 40] },
  { weight: 0.8, values: [41, 60] },
  { weight: 0.1, values: [61, 100] }
]);

/*
 * Test the example and draw results using Google charts API
 */
function testAndDrawResult() {
  var counts = [];
  var i;
  var value;
  // run the function in a loop and count the number of occurrences of each value
  for (i = 0; i < 10000; i++) {
    value = distributionFunction(Math.random());
    counts[value] = (counts[value] || 0) + 1;
  }
  // convert results to datatable and display
  var data = new google.visualization.DataTable();
  data.addColumn("number", "Value");
  data.addColumn("number", "Count");
  for (value = 0; value < counts.length; value++) {
    if (counts[value] !== undefined) {
      data.addRow([value, counts[value]]);
    }
  }
  var chart = new google.visualization.ColumnChart(document.getElementById("chart"));
  chart.draw(data);
}
google.load("visualization", "1", { packages: ["corechart"] });
google.setOnLoadCallback(testAndDrawResult);

<script src="https://www.google.com/jsapi"></script>
<div id="chart"></div>

Oto ważone rozwiązanie dla 3/4 40-60 i 1/4 poza tym zakresem.

function weighted() {

  var w = 4;

  // number 1 to w
  var r = Math.floor(Math.random() * w) + 1;

  if (r === 1) { // 1/w goes to outside 40-60
    var n = Math.floor(Math.random() * 80) + 1;
    if (n >= 40 && n <= 60) n += 40;
    return n
  }
  // w-1/w goes to 40-60 range.
  return Math.floor(Math.random() * 21) + 40;
}

function test() {
  var counts = [];

  for (var i = 0; i < 2000; i++) {
    var n = weighted();
    if (!counts[n]) counts[n] = 0;
    counts[n] ++;
  }
  var output = document.getElementById('output');
  var o = "";
  for (var i = 1; i <= 100; i++) {
    o += i + " - " + (counts[i] | 0) + "\n";
  }
  output.innerHTML = o;
}

test();

<pre id="output"></pre>

Ok, więc zdecydowałem się dodać kolejną odpowiedź, ponieważ czułem się tak, jakby moja ostatnia odpowiedź, a także większość odpowiedzi tutaj, wykorzystywały jakiś pół statystyczny sposób uzyskania wyniku typu krzywej dzwonowej. Podany poniżej kod działa tak samo, jak podczas rzutu kostką. Dlatego najtrudniej jest zdobyć 1 lub 99, ale najłatwiej zdobyć 50.

var loops = 10; //Number of numbers generated
var min = 1,
    max = 50;
var div = $("#results").html(random());

function random() {
    var values = "";
    for (var i = 0; i < loops; i++) {
        var one = generate();
        var two = generate();
        var ans = one + two - 1;
        var num = values += ans + "<br/>";
    }
    return values;
}

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

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
<div id="results"></div>

Polecam użycie rozkładu beta do wygenerowania liczby między 0-1, a następnie przeskalowanie. Jest dość elastyczny i może tworzyć wiele różnych kształtów dystrybucji.

Oto szybki i brudny sampler:

rbeta = function(alpha, beta) {
 var a = 0   
 for(var i = 0; i < alpha; i++)   
    a -= Math.log(Math.random())

 var b = 0   
 for(var i = 0; i < beta; i++)   
    b -= Math.log(Math.random())

  return Math.ceil(100 * a / (a+b))
}

var randNum;
// generate random number from 1-5
var freq = Math.floor(Math.random() * (6 - 1) + 1);
// focus on 40-60 if the number is odd (1,3, or 5)
// this should happen %60 of the time
if (freq % 2){
    randNum = Math.floor(Math.random() * (60 - 40) + 40);
}
else {
    randNum = Math.floor(Math.random() * (100 - 1) + 1);
}

Najlepszym rozwiązaniem tego problemu jest BlueRaja - Danny Pflughoeft, ale myślę, że warto wspomnieć o nieco szybszym i bardziej ogólnym rozwiązaniu.

Kiedy muszę wygenerować liczby losowe (ciągi, pary współrzędnych itp.) Spełniające dwa wymagania

1. Zestaw wyników jest dość mały. (nie większe niż liczby 16K)
2. Zestaw wyników jest dyskretny. (jak tylko liczby całkowite)

Zwykle zaczynam od utworzenia tablicy liczb (ciągów, par współrzędnych itp.) Spełniających wymagania (w twoim przypadku: tablicy liczb zawierającej liczby bardziej prawdopodobne wiele razy). Następnie wybieram losowy element tej tablicy. W ten sposób musisz wywołać kosztowną losową funkcję tylko raz na przedmiot.

Dystrybucja

 5% for [ 0,39]
90% for [40,59]
 5% for [60,99]

Rozwiązanie

var f = Math.random();
if (f < 0.05) return random(0,39);
else if (f < 0.95) return random(40,59);
else return random(60,99);

Ogólne rozwiązanie

random_choose([series(0,39),series(40,59),series(60,99)],[0.05,0.90,0.05]);

function random_choose (collections,probabilities)
{
    var acc = 0.00;
    var r1 = Math.random();
    var r2 = Math.random();

    for (var i = 0; i < probabilities.length; i++)
    {
      acc += probabilities[i];
      if (r1 < acc)
        return collections[i][Math.floor(r2*collections[i].length)];
    }

    return (-1);
}

function series(min,max)
{
    var i = min; var s = [];
    while (s[s.length-1] < max) s[s.length]=i++;
    return s;
}

Możesz użyć liczby losowej pomocnika, aby wygenerować liczby losowe w 40-60 lub 1-100:

// 90% of random numbers should be between 40 to 60.
var weight_percentage = 90;

var focuse_on_center = ( (Math.random() * 100) < weight_percentage );

if(focuse_on_center)
{
	// generate a random number within the 40-60 range.
	alert (40 + Math.random() * 20 + 1);
}
else
{
	// generate a random number within the 1-100 range.
	alert (Math.random() * 100 + 1);
}

Jeśli możesz użyć tej gaussianfunkcji, użyj jej. Ta funkcja zwraca normalną liczbę za pomocą average 0isigma 1 .

95% tej liczby mieści się w zakresie average +/- 2*sigma. Twój average = 50i sigma = 5tak

randomNumber = 50 + 5*gaussian()

Najlepszym sposobem na to jest wygenerowanie liczby losowej, która jest równomiernie rozłożona na pewien zestaw liczb, a następnie zastosowanie funkcji projekcji do zbioru od 0 do 100, w którym prawdopodobieństwo, że projekcja uderzy w pożądane liczby.

Zazwyczaj matematycznym sposobem osiągnięcia tego jest wykreślenie funkcji prawdopodobieństwa liczb, które chcesz. Możemy użyć krzywej dzwonowej, ale dla łatwiejszego obliczenia wystarczy pracować z odwróconą parabolą.

Zróbmy parabolę w taki sposób, aby jej korzenie były równe 0 i 100 bez wypaczania. Otrzymujemy następujące równanie:

f(x) = -(x-0)(x-100) = -x * (x-100) = -x^2 + 100x

Teraz cały obszar pod krzywą od 0 do 100 jest reprezentatywny dla naszego pierwszego zestawu, w którym chcemy wygenerować liczby. Tam generacja jest całkowicie losowa. Wszystko, co musimy zrobić, to znaleźć granice naszego pierwszego zestawu.

Dolna granica to oczywiście 0. Górna granica jest całką naszej funkcji przy 100, czyli

F(x) = -x^3/3 + 50x^2
F(100) = 500,000/3 = 166,666.66666 (let's just use 166,666, because rounding up would make the target out of bounds)

Wiemy więc, że musimy wygenerować liczbę pomiędzy 0 a 166 666. Następnie musimy po prostu wziąć tę liczbę i rzutować ją do naszego drugiego zestawu, który wynosi od 0 do 100.

Wiemy, że liczba losowa, którą wygenerowaliśmy, jest jakąś całką naszej paraboli z wejściem x od 0 do 100. Oznacza to, że po prostu musimy założyć, że liczba losowa jest wynikiem F (x) i rozwiązać dla x.

W tym przypadku F (x) jest równaniem sześciennym, aw postaci F(x) = ax^3 + bx^2 + cx + d = 0prawdziwe są następujące stwierdzenia:

a = -1/3
b = 50
c = 0
d = -1 * (your random number)

Rozwiązanie tego dla x daje rzeczywistą liczbę losową, której szukasz, która z pewnością mieści się w przedziale [0, 100] i znacznie większe prawdopodobieństwo, że znajdzie się bliżej środka niż krawędzi.

Ta odpowiedź jest naprawdę dobra . Ale chciałbym opublikować instrukcje implementacyjne (nie jestem w JavaScript, więc mam nadzieję, że zrozumiesz) dla innej sytuacji.

Załóżmy, że masz zakresy i wagi dla każdego zakresu:

ranges - [1, 20], [21, 40], [41, 60], [61, 100]
weights - {1, 2, 100, 5}

Wstępne informacje statyczne mogą być buforowane:

1. Suma wszystkich wag (w próbce 108)
2. Granice wyboru zakresu. To w zasadzie ta formuła: Boundary[n] = Boundary[n - 1] + weigh[n - 1]i Boundary[0] = 0. Próbka maBoundary = {0, 1, 3, 103, 108}

Generowanie liczb:

1. Wygeneruj losową liczbę Nz zakresu [0, Suma wszystkich wag).
2. for (i = 0; i < size(Boundary) && N > Boundary[i + 1]; ++i)
3. Wybierz izakres i wygeneruj losową liczbę w tym zakresie.

Dodatkowa uwaga na temat optymalizacji wydajności. Zakresy nie muszą być zamawiane ani w kolejności rosnącej, ani malejącej, dlatego w celu uzyskania większego zasięgu zasięg o największej wadze powinien być pierwszy, a najmniejszy - ostatni.