Merkeze odaklanmış rastgele bir sayı al

1-100 arasında rastgele bir sayı almak ve sonuçları esas olarak 40-60 aralığında tutmak mümkün müdür? Yani, bu aralıktan nadiren çıkacak, ama esas olarak bu aralıkta olmasını istiyorum ... JavaScript / jQuery ile mümkün mü?

Şu anda sadece temel olanı kullanıyorum Math.random() * 100 + 1.

En basit yol, 0-50 arasında iki rastgele sayı üretmek ve bunları bir araya getirmek olacaktır.

Bu, 50'ye karşı önyargılı bir dağıtım verir, aynı şekilde iki zar önyargısını 7'ye doğru yuvarlar.

Aslında, daha fazla sayıda "zar" kullanarak (@Falco'nun önerdiği gibi) , çan eğrisine daha yakın bir yaklaşım yapabilirsiniz:

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/

Burada özel çözümler sunan bazı iyi cevaplarınız var; Size genel çözümü tarif edeyim. Problem şu:

• Ben 0 ve 1 arasında az ya da çok düzgün bir şekilde dağıtılmış rasgele sayılar bir kaynak var .
• Farklı bir dağılımı takip eden rasgele sayılar dizisi üretmek istiyorum.

Bu sorunun genel çözümü, kuantil işlevini istediğiniz dağıtım ve sonra tekdüze kaynağının çıkışına kuantil fonksiyonunu uygular.

Kuantil fonksiyonudur ters bir integrali istediğiniz bir dağılım işlevinin . Dağıtım işlevi, eğrinin bir kısmının altındaki alanın, rastgele seçilen öğenin o kısımda olma olasılığına eşit olduğu işlevdir.

Burada nasıl yapılacağına dair bir örnek vereceğim:

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

Buradaki kod C # 'dadır, ancak ilkeler herhangi bir dil için geçerlidir; çözümü JavaScript'e uyarlamak kolay olmalıdır.

Sayı dizileri vb. Almak etkili değildir. 0 ile 100 arasında rastgele bir sayı alan bir eşleme almanız ve ihtiyacınız olan dağıtımla eşleştirmeniz gerekir. Yani sizin durumunuzda, aralığınızın ortasında en fazla değere sahip bir dağıtım elde edebilirsiniz.f(x)=-(1/25)x2+4x

Sayının "sınırların dışına çıkmasına" izin verilmesi için "şans" gibi bir şey yapabilirim. Bu örnekte, sayının% 20'si 1-100, aksi takdirde 40-60 olacaktır:

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

keman: http://jsfiddle.net/kbv39s9w/

Bu sorunu birkaç yıl önce çözmem gerekiyordu ve çözümüm diğer cevaplardan daha kolaydı.

Sınırlar arasında 3 rasgele oluşturdum ve bunların ortalamasını aldım. Bu, sonucu merkeze doğru çeker, ancak ekstremitelere ulaşmayı tamamen mümkün kılar.

O görünüyor aptal ama rand iki kez kullanabilirsiniz:

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

Elbette mümkün. Rastgele 1-100 yapın. Sayı <30 ise, 40-60 aralığında değilse 1-100 aralığında bir sayı oluşturun.

Bu tür rastgele sayılar üretmenin birçok farklı yolu vardır. Bunu yapmanın bir yolu, birden çok tekdüze rasgele sayının toplamını hesaplamaktır. Kaç tane rastgele sayı topladığınız ve aralıklarının ne olduğu son dağılımın nasıl görüneceğini belirleyecektir.

Ne kadar çok sayı toplarsanız, merkeze o kadar önyargılı olur. Sorunuzda 1 rastgele sayının toplamını kullanmak zaten önerildi, ancak fark ettiğiniz gibi aralığın merkezine doğru önyargılı değil. Diğer cevaplar 2 rasgele sayının toplamını veya 3 rasgele sayının toplamını kullanmayı önermektedir .

Daha rasgele sayıların toplamını alarak aralığın merkezine doğru daha fazla önyargı elde edebilirsiniz. En uçta, her biri 0 veya 1 olan 99 rasgele sayının toplamını alabilirdiniz. Bu bir binom dağılımı olacaktır. (Binom dağılımları bir anlamda normal dağılımların ayrık versiyonu olarak görülebilir). Bu hala teoride tüm menzili kapsayabilir, ancak merkeze doğru çok fazla önyargıya sahiptir, asla uç noktalara ulaştığını görmeyi beklememelisiniz.

Bu yaklaşım, ne kadar önyargı istediğinizi değiştirebileceğiniz anlamına gelir.

Bunun gibi bir şey kullanmaya ne dersiniz:

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>

Kodladığım yol birkaç değişken belirlemenize izin verir:
döngüler = sonuç sayısı
dener sayısı = fonksiyonun while döngüsünde çalışmayı durdurmadan önce 40-60 arasında bir sayı almaya çalışacağı sayı

Ek bonus: Do süre kullanır !!! Mükemmelliği en iyi şekilde

Sen arasında rasgele değerler eşleştiren bir fonksiyon yazabiliriz [0, 1)için [1, 100]ağırlığına göre. Bu örneği düşünün:

Burada, 0.95değer arasında değer eşlenir [61, 100].
Aslında .05 / .1 = 0.5, eşleştirildiğinde [61, 100],81 .

İşte işlevi:

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

İşte bu aralığın dışında 3/4 40-60 ve 1/4'te ağırlıklı bir çözüm.

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>

Tamam, bu yüzden başka bir cevap eklemeye karar verdim çünkü son cevabımın yanı sıra buradaki çoğu cevap gibi bir çan eğrisi tipi sonuç dönüşü elde etmek için bir çeşit yarı istatistiksel yol kullanın. Aşağıda verdiğim kod, bir zar attığınız gibi çalışır. Bu nedenle, 1 veya 99 almak en zor, ancak 50 almak en kolaydır.

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>

Beta dağıtımını kullanmanızı öneririm0-1 arasında bir sayı oluşturmak ardından ölçeklendirmenizi . Oldukça esnektir ve birçok farklı dağıtım şekli oluşturabilir.

İşte hızlı ve kirli bir örnekleyici:

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

Bu sorunu hedefleyen en iyi çözüm, BlueRaja - Danny Pflughoeft tarafından önerilen çözümdür, ancak bence biraz daha hızlı ve daha genel bir çözümden bahsetmeye değer.

İki gereksinimi karşılayan rastgele sayılar (dizeler, koordinat çiftleri, vb.) Oluşturmam gerektiğinde

1. Sonuç kümesi oldukça küçük. (16K numarasından büyük değil)
2. Sonuç kümesi gizli. (yalnızca tam sayı gibi)

Genellikle gereksinimi karşılayan bir dizi sayı (dizeler, koordinat çiftleri, vb.) Oluşturarak başlıyorum (Sizin durumunuzda: daha olası olanları birden çok kez içeren bir sayı dizisi.), Sonra o dizinin rastgele bir öğesini seçin. Bu şekilde, her öğe için pahalı rastgele işlevi yalnızca bir kez çağırmanız gerekir.

dağıtım

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

Çözüm

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

Genel Çözüm

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

40-60 veya 1-100 arasında rasgele sayılar üretip üretmemek için yardımcı rasgele bir sayı kullanabilirsiniz:

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

Eğer kullanabiliyorsa gaussianişlevini kullanın. Bu işlev average 0ve ile normal sayıyı döndürür sigma 1.

Bu sayının% 95'i içindedir average +/- 2*sigma. Sizin average = 50ve sigma = 5böylece

randomNumber = 50 + 5*gaussian()

Bunu yapmanın en iyi yolu, belirli bir sayı kümesinde eşit olarak dağıtılan rasgele bir sayı oluşturmak ve ardından 0 ile 100 arasındaki kümeye, bir projeksiyonun istediğiniz sayılara çarpma olasılığının daha yüksek olduğu bir projeksiyon işlevi uygulamaktır.

Genellikle bunu başarmanın matematiksel yolu, istediğiniz sayıların olasılık fonksiyonunu çizmektir. Çan eğrisini kullanabiliriz, ancak daha kolay hesaplama uğruna sadece ters çevrilmiş bir parabolle çalışalım.

Bir parabol yapalım, kökleri eğilmeden 0 ve 100'de olacak. Aşağıdaki denklemi elde ederiz:

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

Şimdi, 0 ile 100 arasındaki eğrinin altındaki tüm alan, sayıların üretilmesini istediğimiz ilk setimizi temsil ediyor. Orada, nesil tamamen rastgeledir. Yani, tek yapmamız gereken ilk setimizin sınırlarını bulmak.

Alt sınır elbette 0'dır. Üst sınır 100'deki fonksiyonumuzun integralidir.

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)

Bu yüzden, 0 ile 166.666 arasında bir sayı üretmemiz gerektiğini biliyoruz. Ardından, bu sayıyı almamız ve 0 ile 100 arasındaki ikinci setimize yansıtmamız gerekir.

Oluşturduğumuz rastgele sayının, 0 ile 100 arasında x girişi olan parabolümüzün bir integrali olduğunu biliyoruz. Bu, rastgele sayının F (x) sonucu olduğunu varsaymamız ve x için çözmemiz gerektiği anlamına gelir.

Bu durumda, F (x) kübik bir denklemdir ve formda F(x) = ax^3 + bx^2 + cx + d = 0aşağıdaki ifadeler doğrudur:

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

Bunu x için çözdüğünüzde, [0, 100] aralığında olduğu garanti edilen aradığınız gerçek rasgele sayı ve kenarlara göre merkeze yakın olma olasılığı daha yüksektir.

Bu cevap gerçekten çok iyi . Ancak, farklı durumlar için uygulama talimatları göndermek istiyorum (JavaScript'e girmiyorum, umarım anlayacaksınız).

Her aralık için aralıklarınız ve ağırlıklarınız olduğunu varsayın:

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

İlk Statik Bilgi önbelleğe alınabilir:

1. Tüm ağırlıkların toplamı (108 örnek)
2. Aralık seçim sınırları. Temel olarak bu formül: Boundary[n] = Boundary[n - 1] + weigh[n - 1]ve Boundary[0] = 0. Örnek varBoundary = {0, 1, 3, 103, 108}

Sayı oluşturma:

1. N[0, tüm ağırlıkların toplamı) aralığından rastgele sayı üretin .
2. for (i = 0; i < size(Boundary) && N > Boundary[i + 1]; ++i)
3. iAralığı alın ve bu aralıkta rastgele sayı oluşturun.

Performans optimizasyonları için ek not. Aralıkların ne artan ne de azalan düzende sıralanması gerekmez, bu nedenle daha hızlı aralık için en yüksek ağırlığa sahip arama aralığı önce ve en düşük ağırlığa sahip olan bir son olmalıdır.