केंद्र पर केंद्रित एक यादृच्छिक संख्या प्राप्त करें

Question

क्या 1-100 के बीच एक यादृच्छिक संख्या प्राप्त करना और मुख्य रूप से परिणाम 40-60 सीमा के भीतर रखना संभव है? मेरा मतलब है, यह शायद ही कभी उस सीमा से बाहर जाएगा, लेकिन मैं चाहता हूं कि यह मुख्य रूप से उस सीमा के भीतर हो ... क्या यह जावास्क्रिप्ट / jQuery के साथ संभव है?

अभी मैं सिर्फ मूल का उपयोग कर रहा हूं Math.random() * 100 + 1।

Comments

en.wikipedia.org/wiki/…

— रोको सी। बुलजन

codetheory.in/…

— जोश

संभव डुप्लिकेट: stackoverflow.com/questions/1527803/…

— महेदी सबुज

मुझे पसंद है कि यह प्रश्न कहां जा रहा है, लेकिन मुझे लगता है कि यह अधिक विशिष्ट होना चाहिए। क्या आप एक Z- वितरण (घंटी वक्र), एक त्रिकोण वितरण, या किसी प्रकार का आरा वितरण चाहते हैं? मेरी राय में इस प्रश्न का उत्तर देने के लिए कई संभावनाएं हैं।

— पैट्रिक रॉबर्ट्स

यह जावास्क्रिप्ट में किया जा सकता है, लेकिन निश्चित रूप से jQuery के साथ कुछ नहीं करना है ... :)

— ए। वोल्फ

Answer 1

सबसे सरल तरीका 0-50 से दो यादृच्छिक संख्याओं को उत्पन्न करना और उन्हें एक साथ जोड़ना होगा।

यह एक वितरण को 50 की ओर से पक्षपाती बनाता है, उसी तरह से 7 की ओर दो पासा को लुढ़काता है।

वास्तव में, बड़ी संख्या में "पासा" का उपयोग करके (जैसा कि @ फाल्को सुझाव देता है) , आप एक घंटी-वक्र के करीब एक करीब बना सकते हैं:

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/

Comments

यह एक आसान और त्वरित समाधान है, जिसे आसानी से अधिक भारित किया जा सकता है, अधिक संख्याएँ जैसे 4 x (0-25) जोड़कर और आपको वितरण के लिए एक अच्छा घंटी-वक्र देगा!

— फाल्को

यह एक शानदार कोड है। मुझे लगता है कि मुझे इससे प्यार है। सरल, त्वरित, कुशल; बहुत बढ़िया जवाब। इसे पोस्ट करने के लिए आपका धन्यवाद।

— ctwheels

शानदार उत्तर, लेकिन अगर कोई भी सामान्य वितरण उत्पन्न करने के लिए इसका उपयोग करने का इरादा रखता है, तो यह बहुत ही अक्षम है (और आपको वांछित साधन और मानक विचलन प्राप्त करने के लिए इसे बदलने की आवश्यकता है)। एक अधिक कुशल विकल्प बॉक्स-मुलर ट्रांसफॉर्मेशन होगा, जिसे लागू करने और समझने में काफी आसान है यदि आप थोड़ा सा गणित जानते हैं।

— ब्रेंडन

@RaziShaban यह बहुत सहज है: मरने वाले फेंको का केवल एक संयोजन है जो 2 (सिर्फ साँप की आंखों) को जोड़ता है, लेकिन 6 अलग-अलग संयोजन हैं जो 7 (6-1, 5-2, 4-3, 3-) तक जोड़ते हैं 4, 2-5, 1-6)। यदि आप N- पक्षीय पासा को सामान्य करते हैं, तो चोटी हमेशा N + 1 होती है।

— बमर

@RaziShaban यादृच्छिक चर का अध्ययन आँकड़ों का एक केंद्रीय हिस्सा है। तथ्य यह है कि जैसा कि हम पासा बढ़ाते हैं, हम एक सामान्य वितरण का दृष्टिकोण लेते हैं, यह प्रसिद्ध केंद्रीय सीमा प्रमेय है ।

— ब्लूराजा - डैनी पफ्लुगुफ्ट

Answer 2

आपके पास यहां कुछ अच्छे उत्तर हैं जो विशिष्ट समाधान देते हैं; मुझे आप के लिए सामान्य समाधान का वर्णन करते हैं। यह समस्या है:

• मेरे पास 0 और 1 के बीच अधिक-या-कम समान रूप से वितरित यादृच्छिक संख्याओं का स्रोत है ।
• मैं यादृच्छिक संख्याओं के अनुक्रम का उत्पादन करना चाहता हूं जो एक अलग वितरण का पालन करते हैं।

इस समस्या का सामान्य समाधान क्वांटाइल फ़ंक्शन का कार्य करना है कि आप अपने वांछित वितरण को पूरा करें और फिर अपने समान स्रोत के आउटपुट में मात्रात्मक कार्य को लागू करें।

क्वांटाइल फ़ंक्शन आपके इच्छित वितरण फ़ंक्शन के अभिन्न का विलोम है । वितरण फ़ंक्शन वह फ़ंक्शन है जहां वक्र के एक हिस्से के नीचे का क्षेत्र इस संभावना के बराबर है कि यादृच्छिक रूप से चुना गया आइटम उस हिस्से में होगा।

मैं यहाँ ऐसा करने का एक उदाहरण देता हूँ:

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

वहां का कोड C # में है, लेकिन सिद्धांत किसी भी भाषा पर लागू होते हैं; जावास्क्रिप्ट के समाधान को अनुकूलित करने के लिए यह सीधा होना चाहिए।

Comments

मुझे यह तरीका पसंद है। जोड़ना चाह सकते हैं कि एक जावास्क्रिप्ट लाइब्रेरी मौजूद है जो गौसियन (और अन्य गैर-सामान्य) वितरण उत्पन्न करती है: simjs.com/random.html

— फ्लोरिस

Answer 3

संख्याओं के सरणियाँ लेना, आदि कुशल नहीं है। आपको एक मैपिंग लेनी चाहिए जो 0 से 100 के बीच एक यादृच्छिक संख्या लेती है और आपके द्वारा आवश्यक वितरण के लिए मैप करती है। तो आपके मामले में, आप अपनी श्रेणी के मध्य में सबसे अधिक मानों के साथ वितरण प्राप्त कर सकते हैं ।f(x)=-(1/25)x2+4x

Comments

हमें वास्तव में नहीं पता है कि वितरण की क्या आवश्यकता है। "मुख्य रूप से 40-60" मेरे लिए एक घंटी-वक्र का अर्थ है।

— लेफ्टी

हाँ, आप सही हैं, शायद आपको एक बेहतर मैपिंग की आवश्यकता है, लेकिन यह तुच्छ है

— iCaramba

मैं इसके लिए आपका शब्द लेता हूं क्योंकि यह मेरी विशेषज्ञता का क्षेत्र नहीं है। क्या आप फ़ंक्शन को समायोजित कर सकते हैं और नया वक्र प्रदर्शित कर सकते हैं?

— लेफ्टी

@ लेफ्टी - x0 और 100 के बीच सरलीकृत बेल वक्र ( इस प्रश्न से लिया गया ):y = (Math.sin(2 * Math.PI * (x/100 - 1/4)) + 1) / 2

— स्फिंक्सएक्स

@Sphinxxx यह एक घंटी वक्र नहीं है, यह एक पाप वक्र है। एक घंटी वक्र एक्स-अक्ष को कभी नहीं छूता है।

— ब्लूराजा - डैनी पफ्लुगुएफ्ट

Answer 4

मैं "सीमा से बाहर" जाने की अनुमति के लिए कुछ "सेटअप" जैसा कुछ कर सकता हूं। इस उदाहरण में, 20% संभावना संख्या 1-100 होगी, अन्यथा, 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>

फिडल: http://jsfiddle.net/kbv39s9w/

Comments

हो सकता है कि अधिक सांख्यिकीय विवरण वाला कोई व्यक्ति मुझे सही कर सकता है, और हालांकि यह वह प्राप्त करता है जो ओपी की तलाश में है (इसलिए मैंने वोट दिया), लेकिन यह वास्तव में 20% समय से बाहर सीमा का # चयन नहीं करेगा, सही? इस समाधान में, 20% समय आपके पास तब 1-100 से एक # चुनने का अवसर होगा, जिसमें 40-60 शामिल हैं। यह वास्तव में नहीं होगा (0.2 * 0.8) 16% एक # सीमा से बाहर का चयन करने के लिए, या मैं कुछ याद कर रहा हूँ?

— जोश

नहीं, तुम सही हो। यह सिर्फ मेरा शब्दांकन है। मैं इसे सही कर दूंगा। धन्यवाद!

— बिटवाइज़ क्रिएटिव

@ जोश - यह सुंदर जगह पर है। यहाँ एक सरल प्रमाण है जो कि jsfiddle.net/v51z8sd5 जैसा दिखता है । यह सीमा से बाहर पाए जाने वाले अंकों का प्रतिशत और लगभग 0.16 (16%) पर मंडराएगा।

— ट्रैविस जे

Answer 5

मुझे कुछ साल पहले इस समस्या को हल करने की आवश्यकता थी और मेरा समाधान अन्य उत्तरों की तुलना में आसान था।

मैंने सीमा के बीच 3 रैंडम उत्पन्न किए और उन्हें औसत किया। यह परिणाम को केंद्र की ओर खींचता है लेकिन यह चरम सीमाओं तक पहुंचने के लिए पूरी तरह से संभव बनाता है।

Comments

यह ब्लूराजा के जवाब से बेहतर / अलग कैसे है? वहां, वह (2,3, ... कोई भी संख्या जो आप चाहते हैं) को यादृच्छिक संख्या में ले जाता है और औसत लेता है। परिणाम आपके लिए समान है जब आप BellFactor3 का उपयोग करते हैं

— फ्लोरिस

@ अच्छी तरह से, मैं भाषाओं के सी परिवार में कोड नहीं करता हूं, ताकि जवाब भी नहीं दिखे, हालांकि यह मेरे जवाब के रूप में एक ही काम कर रहा था जब तक कि मैं अभी इसे फिर से पढ़ता हूं। मैंने थोड़ी-सी ट्रायल-एंड-एरर करके अपना तरीका बनाया और पाया कि 3 रैंडम सही संख्या थी। इसके अलावा, मेरा एक लाइन में किया जा सकता है और अभी भी समझने में आसान हो सकता है।

— लेफ्टी

वास्तव में? आपको नहीं लगता कि जेएस और सी के बीच कोई समानता है? ठीक है, ठीक है, मैं सिर्फ यह कहता हूं कि मैं उन भाषाओं के EITHER नहीं बोल सकता, न ही जावा, जो, मेरे लिए, उन सभी भाषाओं की तुलना में समान हैं, जिनसे मैं परिचित हूं।

— लेफ्टी

उचित बिंदु, मैं वास्तव में केवल शीर्षक के रूप में आकर्षित हुआ था क्योंकि मैं अपने आप को हल कर रहा था और जिस तरह से मैंने ऐसा किया, उस पर मुझे काफी गर्व था। फिर से, मुझे नहीं पता था कि यह एक जेएस सवाल है जब तक कि आपने सिर्फ यह नहीं कहा। वास्तव में भाग्यशाली, क्योंकि मेरी तकनीक भाषा पर निर्भर नहीं है और कुछ लोगों को लगता है कि यह एक उपयोगी उत्तर है।

— लेफ्टी

जावास्क्रिप्ट वास्तव में एक सी-पारिवारिक भाषा है ... लेकिन अच्छी तरह से आह।

— जोरेन

Answer 6

यह बेवकूफ लग रहा है लेकिन आप दो बार रैंड का उपयोग कर सकते हैं:

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

Answer 7

यकीन है कि यह संभव है। एक यादृच्छिक 1-100 बनाओ। यदि संख्या <30 है, तो श्रेणी 1-100 में संख्या उत्पन्न करें यदि सीमा 40-60 में उत्पन्न नहीं होती है।

Answer 8

इस तरह के यादृच्छिक संख्याओं को उत्पन्न करने के लिए कई अलग-अलग तरीके हैं। ऐसा करने का एक तरीका यह है कि एक समान रूप से यादृच्छिक संख्याओं के योग की गणना की जाए। आप कितने रैंडम नंबर लेते हैं और उनकी सीमा क्या है, यह निर्धारित करेगा कि अंतिम वितरण कैसा दिखेगा।

आप जितनी अधिक संख्या में योग करेंगे, उतना ही यह केंद्र की ओर से पक्षपाती होगा। 1 यादृच्छिक संख्या के योग का उपयोग करना आपके प्रश्न में पहले से ही प्रस्तावित था, लेकिन जैसा कि आप नोटिस करते हैं कि सीमा के केंद्र के लिए पक्षपाती नहीं है। अन्य उत्तरों में 2 यादृच्छिक संख्याओं के योग या 3 यादृच्छिक संख्याओं के योग का प्रस्ताव है ।

आप अधिक यादृच्छिक संख्याओं का योग लेकर सीमा के केंद्र की ओर और भी अधिक पूर्वाग्रह प्राप्त कर सकते हैं। चरम पर आप 99 यादृच्छिक संख्याओं का योग ले सकते हैं जो प्रत्येक 0 या 1 थे। यह एक द्विपद वितरण होगा। (द्विपद वितरण कुछ अर्थों में सामान्य वितरण के असतत संस्करण के रूप में देखा जा सकता है)। यह अभी भी सिद्धांत में पूरी श्रृंखला को कवर कर सकता है, लेकिन इसमें केंद्र के प्रति इतना पूर्वाग्रह है कि आपको इसे अंतिम बिंदु तक पहुंचने की उम्मीद नहीं करनी चाहिए।

इस दृष्टिकोण का मतलब है कि आप बस इतना पूर्वाग्रह कर सकते हैं कि आप कितना पूर्वाग्रह चाहते हैं।

Answer 9

इस तरह से कुछ का उपयोग करने के बारे में क्या:

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>

जिस तरह से मैंने इसे कोडित किया है वह आपको चर के एक जोड़े को सेट करने की अनुमति देता है:
छोरों = परिणामों की संख्या की
कोशिश करता है संख्या की = कई बार फ़ंक्शन 40-60 के बीच एक संख्या प्राप्त करने की कोशिश करेगा इससे पहले कि यह लूप के माध्यम से चलना बंद हो जाए।

जोड़ा गया बोनस: यह उपयोग करता है जबकि !!! अपने सबसे अच्छे रूप में सजगता

Answer 10

आप एक समारोह है कि बीच यादृच्छिक मूल्यों नक्शे लिख सकते हैं [0, 1)करने के लिए [1, 100]वजन के अनुसार। इस उदाहरण पर विचार करें:

यहाँ, 0.95मान के बीच का मान मैप करता है [61, 100]।
वास्तव में हमारे पास .05 / .1 = 0.5, जो, जब मैप किया जाता है [61, 100], तो पैदावार होती है81 ।

यहाँ समारोह है:

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

Answer 11

यहां उस श्रेणी के बाहर 3/4 40-60 और 1/4 पर एक भारित समाधान है।

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>

Answer 12

ठीक है, इसलिए मैंने एक और उत्तर जोड़ने का फैसला किया क्योंकि मुझे अपना अंतिम उत्तर पसंद आया, साथ ही यहाँ अधिकांश उत्तर, बेल-कर्व टाइप रिजल्ट प्राप्त करने के लिए किसी तरह के आधे-सांख्यिकीय तरीके का उपयोग करते हैं। आपके द्वारा नीचे दिया गया कोड उसी तरह काम करता है जैसे आप पासा चलाते हैं। इसलिए, 1 या 99 प्राप्त करना सबसे कठिन है, लेकिन 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>

Answer 13

मैं बीटा वितरण का उपयोग करने की सलाह दूंगा 0-1 के बीच एक संख्या उत्पन्न करने दूंगा, फिर इसे स्केल । यह काफी लचीला है और वितरण के कई अलग-अलग आकार बना सकता है।

यहाँ एक त्वरित और गंदा नमूना है:

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

Answer 14

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

Answer 15

इस समस्या को लक्षित करने का सबसे अच्छा समाधान ब्लूराज द्वारा प्रस्तावित एक है - डैनी पफ्लुघोफ्ट लेकिन मुझे लगता है कि कुछ हद तक तेज और अधिक सामान्य समाधान भी ध्यान देने योग्य है।

---

जब मुझे रैंडम नंबर्स (स्ट्रिंग्स, कोऑर्डिनेट पेयर वगैरह) जेनरेट करने होते हैं, तो दोनों की जरूरतों को पूरा करता है

1. परिणाम सेट काफी छोटा है। (16K संख्या से बड़ा नहीं)
2. परिणाम सेट विवेकपूर्ण है। (केवल पूर्णांक संख्याओं की तरह)

मैं आम तौर पर आवश्यकता को पूरा करने वाली संख्याओं (स्ट्रिंग्स, समन्वय जोड़े आदि) की एक सरणी बनाकर शुरू करता हूं (आपके मामले में: कई बार अधिक संभावित वाले संख्याओं की एक सरणी।), फिर उस सरणी का एक यादृच्छिक आइटम चुनें। इस तरह, आपको केवल प्रति आइटम एक बार महंगे यादृच्छिक फ़ंक्शन को कॉल करना होगा।

Comments

यदि आप विकल्पों की एक सरणी को प्रीफ़िल करने जा रहे हैं, तो आप उन्हें बाद में फेरबदल भी कर सकते हैं। तब तक आप उन्हें तब तक पकड़ सकते हैं जब तक आप बाहर नहीं निकल जाते। यदि आप सूची के अंत में आते हैं तो फिर से फेरबदल करें।

— Geobits

@Geobits किसी सूची में फेरबदल करना कहीं अधिक संसाधन-गहन कार्य है तो बेतरतीब ढंग से इसके तत्वों में से एक को चुनना। यह केवल एक अच्छा विकल्प है अगर सूची का अनुमान लगाना है।

— mg30rg

लेकिन आप इसे केवल हर बार के बजाय सूची के चक्र के अनुसार ही करते हैं। यदि आप इसे प्रीप्रोसेस करते हैं (क्योंकि आपके पास वैसे भी प्रीप्रोसेसिंग कदम है, तो मुझे लगता है कि यह ठीक है), फिर बाद में प्रत्येक नंबर प्राप्त करना बहुत तेज है। जब भी आपके पास समय कम हो, तो आप फेरबदल कर सकते हैं, या जान सकते हैं कि आपको थोड़े समय के लिए यादृच्छिक संख्या की आवश्यकता नहीं होगी। बस इसे एक विकल्प के रूप में पेश करने से दोनों (डिस) फायदे हैं।

— 15'15

@Geobits यदि आप इसे अपने तरीके से करते हैं, तो "एकल संभावना" संख्या "गिर जाएगी" और जब तक कि फेरबदल नहीं किया जाता है, तब तक वे परिणाम के रूप में नहीं आ सकते हैं। (यानी यदि आप दो पांसे फेंकने का अनुकरण करते हैं, तो आपके पास दो बार से अधिक संख्या 2 प्राप्त करने का मामूली मौका नहीं होगा।)

— mg30rg

यह एक है ज्यादा ) है, यह नहीं उपयोग करने के लिए, दुर्लभ अनुप्रयोगों के लिए जहां कि ठीक है के अलावा बेहतर कारण

— Geobits

Answer 16

वितरण

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

उपाय

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

सामान्य समाधान

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

Answer 17

आप 40-60 या 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);
}

Answer 18

यदि आप gaussianफ़ंक्शन का उपयोग कर सकते हैं , तो इसका उपयोग करें। यह फ़ंक्शन सामान्य संख्या के साथ average 0और sigma 1।

इस संख्या का 95% भीतर हैं average +/- 2*sigma। आपका average = 50, और sigma = 5इसलिए

randomNumber = 50 + 5*gaussian()

Answer 19

ऐसा करने का सबसे अच्छा तरीका एक यादृच्छिक संख्या उत्पन्न करना है जो संख्याओं के एक निश्चित समूह में समान रूप से वितरित किया जाता है, और फिर 0 और 100 के बीच सेट पर एक प्रक्षेपण फ़ंक्शन लागू करें जहां आप चाहते हैं कि संख्याओं को हिट करने के लिए प्रक्षेपण की अधिक संभावना है।

आमतौर पर इसे प्राप्त करने का गणितीय तरीका आपके द्वारा वांछित संख्याओं की प्रायिकता फ़ंक्शन को प्लॉट कर रहा है। हम घंटी की वक्र का उपयोग कर सकते हैं, लेकिन चलो आसान गणना के लिए बस एक फ़्लिप किए गए पेराबोला के साथ काम करते हैं।

आइए एक परवल को इस तरह बनाएं कि इसकी जड़ें 0 और 100 पर बिना तिरछी लगे रहें। हमें निम्नलिखित समीकरण मिलते हैं:

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

अब, 0 और 100 के बीच के वक्र के नीचे का सारा क्षेत्र हमारे पहले सेट का प्रतिनिधि है जहाँ हम उत्पन्न संख्याएँ चाहते हैं। वहां, पीढ़ी पूरी तरह से यादृच्छिक है। इसलिए, हमें केवल अपने पहले सेट की सीमा का पता लगाने की जरूरत है।

निचला बाउंड, निश्चित रूप से, 0. ऊपरी बाउंड 100 पर हमारे फ़ंक्शन का अभिन्न अंग है, जो है

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)

इसलिए हम जानते हैं कि हमें 0 और 166,666 के बीच कहीं एक संख्या उत्पन्न करने की आवश्यकता है। फिर, हमें बस उस नंबर को लेने की जरूरत है और इसे हमारे दूसरे सेट पर प्रोजेक्ट करना है, जो कि 0 और 100 के बीच है।

हम जानते हैं कि हमने जो रैंडम नंबर जनरेट किया है, वह 0 और 100 के बीच इनपुट x के साथ हमारे पेराबोला का कुछ अभिन्न अंग है। इसका मतलब है कि हमें बस यह मान लेना है कि रैंडम नंबर F (x) का परिणाम है, और x के लिए हल करें।

इस मामले में, एफ (एक्स) एक घन समीकरण है, और फॉर्म में F(x) = ax^3 + bx^2 + cx + d = 0, निम्नलिखित कथन सत्य हैं:

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

X पैदावार के लिए इसे हल करने से आपको वास्तविक रैंडम नंबर की तलाश होती है, जिसकी गारंटी [0, 100] रेंज में होती है और किनारों की तुलना में केंद्र के करीब होने की बहुत अधिक संभावना होती है।

Answer 20

यह उत्तर वास्तव में अच्छा है । लेकिन मैं कार्यान्वयन निर्देश पोस्ट करना चाहूंगा (मैं जावास्क्रिप्ट में नहीं हूं, इसलिए मुझे आशा है कि आप अलग-अलग स्थिति के लिए समझेंगे)।

---

मान लें कि आपके पास हर रेंज के लिए रेंज और वज़न है:

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

---

प्रारंभिक स्टेटिक सूचना, कैश की जा सकती है:

1. सभी भार का योग (नमूने में 108)
2. सीमा चयन सीमाएँ। यह मूल रूप से यह सूत्र है: Boundary[n] = Boundary[n - 1] + weigh[n - 1]और Boundary[0] = 0। नमूना हैBoundary = {0, 1, 3, 103, 108}

संख्या पीढ़ी:

1. Nश्रेणी से यादृच्छिक संख्या उत्पन्न करें [0, सभी भार का योग)।
2. for (i = 0; i < size(Boundary) && N > Boundary[i + 1]; ++i)
3. iवें श्रेणी को लें और उस सीमा में यादृच्छिक संख्या उत्पन्न करें।

---

प्रदर्शन अनुकूलन के लिए अतिरिक्त नोट। पर्वतमाला को न तो चढ़ते और न ही अवरोही क्रम का आदेश देना पड़ता है, इसलिए तेज़ रेंज लुक-अप रेंज के लिए, जिसमें सबसे अधिक वजन होता है, उसे पहले जाना चाहिए और सबसे कम वजन वाले व्यक्ति को अंतिम रूप से जाना चाहिए।