मैं एक "यादृच्छिक" जनरेटर कैसे बना सकता हूं जो पूर्व की घटनाओं से पक्षपाती है?

37

मैं एक मौका आधारित प्रणाली को लागू करना चाह रहा हूं जो पूर्व की घटना से पक्षपाती है।

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

इस तरह की प्रणाली ने उस समय मुझे बहुत ही ज्यादा परेशान किया, और अब मुझे इस तरह के समाधान की आवश्यकता है।

यहाँ मेरी परेशानियाँ हैं:

मैं अनुमान लगा रहा हूं कि मैं इस तरह की प्रणाली को लागू करने पर ऑनलाइन संसाधनों को खोजने में सक्षम होगा, लेकिन मुझे इसे खोजने के लिए प्रासंगिक चर्चा शब्दों की कमी हो सकती है।
इसके अलावा मुझे एक प्रणाली फिट करने के लिए इस दृष्टिकोण की आवश्यकता है जो द्विपद (यानी दो परिणाम) नहीं है, लेकिन इसके बजाय 4 परस्पर अनन्य घटनाएं शामिल हैं।

मेरा वर्तमान दृष्टिकोण एक रैफ़ल टिकट प्रणाली के समान है। जब कोई घटना घटती है तो मैं अन्य सभी घटनाओं के पक्ष में वज़न बदल देता हूँ। यह काम कर सकता है यदि चार घटना समान रूप से होने की संभावना थी, लेकिन मेरे मामले में, बहुत अधिक प्रचलित होने की आवश्यकता है। लेकिन जैसा कि प्रचलित घटना अधिक बार होती है, यह दूसरे के वज़न को उद्देश्य से बहुत अधिक बढ़ा देती है और मुझे लगता है कि घटना के शुरुआती मूल्यों के आसपास औसत टिकट की गिनती रखने के लिए आवश्यक वेट शिफ्ट के लिए संख्याओं का पता लगाना संभव नहीं है। दिया हुआ।

कुछ दिशा संकेत या एक स्पष्ट कट उदाहरण बहुत सराहना की जाएगी।

random

— Sonaten
स्रोत

4

यदि आप एक अति सूक्ष्म या परिष्कृत उत्तर चाहते हैं, तो आपके पास और अधिक भाग्य हो सकते हैं। गणितज्ञों में संभावना के बारे में जटिल सवालों के जवाब देने में सहजता होती है। math.stackexchange.com

— केविन - मोनिका

1

PRNG

— जॉन

6

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

— लिलिएनथाल

1

मैं केविन और लिलिएनथाल के साथ सहमत हूं कि आपको वहां बेहतर जवाब मिल सकता है, लेकिन मैकलिंगन के जवाब को पढ़कर मुझे एहसास हुआ कि यहां जो वर्णन किया जा रहा है वह मार्कोव श्रृंखला के रूप में तैयार किया जा सकता है और यह गेम डेवलपर्स के लिए एक उपयोगी उपकरण हो सकता है। मैं बाद में और अधिक विस्तार से लिखने की कोशिश करूँगा।

— nwellcome 15

1

जैसा कि मैंने यहां कुछ उत्तरों पर संख्याओं को चलाया है, मुझे पता चल रहा है कि कई अलग-अलग बाधाएं हैं, और यह एक समाधान है कि उन सभी को हल करता है जो मुझे आपकी आवश्यकता से अधिक जटिल हो सकता है। आपके उपयोग के मामले में कुछ और बारीकियों में सर्वोत्तम विकल्पों पर संकीर्ण-में मदद मिल सकती है। उदाहरण के लिए, क्या आपकी घटनाओं की संभावनाएँ काफी हद तक समान हैं (उदाहरण के लिए, 20% संभावना के साथ 5 अलग-अलग परिणाम), या बहुत अलग (जैसे: 10% 80% हिट 10% छूट)? क्या आप रन कम करना चाहते हैं (उदाहरण के लिए एक पंक्ति में 3 मिसेज़) या क्लंप्स / वेट्स (उदाहरण के लिए 8 में से 3 मिसेस, या 20 कोशिशें होने से पहले मैं क्रिटिकल हो जाता हूं)?

— DMGregory

19

मूल रूप से, आप जो पूछ रहे हैं, वह एक "अर्ध-यादृच्छिक" इवेंट जनरेटर है जो निम्नलिखित गुणों के साथ घटनाओं को उत्पन्न करता है:

प्रत्येक घटना की औसत दर पहले से निर्दिष्ट होती है।
एक ही घटना एक पंक्ति में दो बार होने की संभावना कम होती है, क्योंकि यह यादृच्छिक पर होगी।
घटनाएं पूरी तरह से अनुमानित नहीं हैं।

ऐसा करने का एक तरीका पहले गैर-यादृच्छिक घटना जनरेटर को लागू करना है जो लक्ष्यों 1 और 2 को संतुष्ट करता है, और फिर 3 को संतुष्ट करने के लिए कुछ यादृच्छिकता जोड़ देता है।

गैर-यादृच्छिक इवेंट जनरेटर के लिए, हम एक साधारण डीथिरिंग एल्गोरिथ्म का उपयोग कर सकते हैं । विशेष रूप से, p ₁ , p ₂ , ..., p _n , घटनाओं 1 के n के सापेक्ष संभावनाएं हैं , और s = p ₁ + p ₂ + ... + p _n भार का योग हो। फिर हम निम्नलिखित एल्गोरिथ्म का उपयोग करके घटनाओं का एक गैर-यादृच्छिक अधिकतम समतुल्य अनुक्रम उत्पन्न कर सकते हैं:

प्रारंभ में, ई ₁ = ई ₂ = ... = ई _एन = 0।
एक घटना बनाने के लिए, प्रत्येक को बढ़ा देते ई _मैं द्वारा पी _मैं , और उत्पादन घटना कश्मीर जिसके लिए ई _{कश्मीर} सबसे बड़ा (संबंधों जैसे चाहें वैसे तोड़ने) है।
कमी ई _के द्वारा s , और चरण 2 से दोहराएँ।

उदाहरण के लिए, तीन घटनाओं A, B और C को p _A = 5, p _B = 4 और p _C = 1 के साथ दिया गया है, यह एल्गोरिथम आउटपुट के निम्नलिखित अनुक्रम जैसा कुछ उत्पन्न करता है:

A B A B C A B A B A A B A B C A B A B A A B A B C A B A B A

ध्यान दें कि 30 घटनाओं के इस क्रम में 15 As, 12 Bs और 3 Cs शामिल हैं। यह काफी आशावादी रूप से वितरित नहीं है - एक पंक्ति में दो अस की कुछ घटनाएं हैं, जिन्हें टाला जा सकता था - लेकिन यह करीब हो जाता है।

अब, इस क्रम में यादृच्छिकता जोड़ने के लिए, आपके पास कई (जरूरी नहीं कि पारस्परिक रूप से अनन्य) विकल्प हों:

आप कुछ उचित आकार एन के लिए, फिलीपींस की सलाह का पालन कर सकते हैं और एन आगामी घटनाओं के "डेक" को बनाए रख सकते हैं । हर बार जब आपको कोई ईवेंट जनरेट करने की आवश्यकता होती है, तो आप डेक से एक रैंडम ईवेंट चुनते हैं, और फिर इसे अगले ईवेंट आउटपुट के साथ ऊपर दिए गए एल्गोरिथ्म द्वारा प्रतिस्थापित करते हैं।

N = 3 के साथ उपरोक्त उदाहरण पर लागू होता है, उदाहरण के लिए :
```
A B A B C A B B A B A B C A A A A B B A B A C A B A B A B A
```
जबकि N = 10 अधिक यादृच्छिक दिखने वाली उपज देता है:
```
A A B A C A A B B B A A A A A A C B A B A A B A C A C B B B
```
ध्यान दें कि कफ़न के कारण आम घटनाएँ A और B बहुत अधिक चलती हैं, जबकि दुर्लभ C घटनाएँ अभी भी काफी अच्छी तरह से समाप्त हो चुकी हैं।
आप सीधे बेतरतीब एल्गोरिथ्म में कुछ यादृच्छिकता इंजेक्षन कर सकते हैं। उदाहरण के लिए, बजाय बढ़ाने की ई _मैं द्वारा पी _मैं चरण 2 में, आप इसे से बढ़ा देते सकता है पी _मैं × यादृच्छिक (0, 2), जहां यादृच्छिक ( एक , ख ) एक समान रूप से के बीच यादृच्छिक संख्या वितरित किया जाता है एक और ख ; यह निम्नलिखित की तरह उत्पादन होगा:
```
A B B C A B A A B A A B A B A A B A A A B C A B A B A C A B
```
या आप e _i को p _i + random (- c , c ) द्वारा बढ़ा सकते हैं , जो उत्पादन करेगा ( c = 0.1 × s के लिए ):
```
B A A B C A B A B A B A B A C A B A B A B A A B C A B A B A
```
या, c = 0.5 × s के लिए :
```
B A B A B A C A B A B A A C B C A A B C B A B B A B A B C A
```
ध्यान दें कि कैसे बहुसांस्कृतिक की तुलना में आम घटनाओं ए और बी की तुलना में, योगात्मक घटनाओं के लिए योगात्मक योजना का अधिक मजबूत यादृच्छिक प्रभाव है; यह वांछनीय हो सकता है या नहीं भी हो सकता है। बेशक, आप भी इन योजनाओं, या वेतन वृद्धि करने के लिए किसी अन्य समायोजन के कुछ संयोजन है, जब तक इस्तेमाल कर सकते हैं के रूप में यह संपत्ति को बरकरार रखता है कि औसत की वेतन वृद्धि ई _मैं बराबर होती है पी _मैं ।
वैकल्पिक रूप से, आप कभी-कभी चुने गए ईवेंट k को यादृच्छिक एक (कच्चे वज़न p _{i के} अनुसार चुना गया ) के स्थान पर डिथरिंग अल्गोरिथम के आउटपुट को बढ़ा सकते हैं । जब तक आप चरण 3 में एक ही k का उपयोग करते हैं जब तक आप चरण 2 में आउटपुट करते हैं, तब तक dithering प्रक्रिया अभी भी यादृच्छिक उतार-चढ़ाव को समाप्त कर देगी।

उदाहरण के लिए, यहां कुछ उदाहरण आउटपुट, प्रत्येक घटना का 10% मौका बेतरतीब ढंग से चुना गया है:
```
B A C A B A B A C B A A B B A B A B A B C B A B A B C A B A
```
और यहां एक उदाहरण है कि प्रत्येक आउटपुट के 50% संभावना यादृच्छिक है:
```
C B A B A C A B B B A A B A A A A A B B A C C A B B A B B C
```
तुम भी, जैसा कि ऊपर वर्णित एक डेक मिश्रण पूल / में विशुद्ध रूप से यादृच्छिक और डिदर्ड घटनाओं का मिश्रण खिलाने पर विचार कर सकते, या शायद का चयन करके हिचकिचाहट एल्गोरिथ्म randomizing कश्मीर बेतरतीब ढंग से, के रूप में द्वारा तौला ई _मैं एस (शून्य के रूप में नकारात्मक वजन इलाज)।

Ps। यहाँ कुछ पूरी तरह से यादृच्छिक घटना क्रम हैं, समान औसत दरों के साथ, तुलना के लिए:

A C A A C A B B A A A A B B C B A B B A B A B A A A A A A A
B C B A B C B A A B C A B A B C B A B A A A A B B B B B B B
C A A B A A B B C B B B A B A B A A B A A B A B A C A A B A

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

भूखंड
^{अर्ध-यादृच्छिक सिक्का फ़्लिप (औसतन 50 से 50 के अनुपात में पूंछ के साथ) उत्पन्न करने के लिए कई रणनीतियों का प्लॉट। क्षैतिज अक्ष फ़्लिप की संख्या है, ऊर्ध्वाधर अक्ष अपेक्षित अनुपात से संचयी दूरी है, जिसे (हेड - टेल) / 2 = हेड - फ़्लिप / 2 के रूप में मापा जाता है।}

भूखंड पर लाल और हरे रंग की लाइनें तुलना के लिए दो गैर-डेक-आधारित एल्गोरिदम दिखाती हैं:

रेड लाइन, नियतात्मक डिथरिंग : सम-संख्या वाले परिणाम हमेशा सिर होते हैं, विषम संख्या वाले परिणाम हमेशा पूंछ होते हैं।
ग्रीन लाइन, स्वतंत्र यादृच्छिक फ़्लिप : प्रत्येक परिणाम को रैंडम रूप से स्वतंत्र रूप से चुना जाता है, जिसमें 50% सिर और 50% पूंछ की संभावना होती है।

अन्य तीन लाइनें (नीला, बैंगनी और सियान) तीन डेक-आधारित रणनीतियों के परिणाम दिखाती हैं, जिनमें से प्रत्येक को 40 कार्डों के डेक का उपयोग करके लागू किया जाता है, जो शुरू में 20 "सिर" कार्ड और 20 "पूंछ" कार्ड से भरा होता है:

नीली रेखा, खाली होने पर भरें : डेक खाली होने तक कार्ड यादृच्छिक रूप से तैयार किए जाते हैं, फिर डेक को 20 "हेड" कार्ड और 20 "टेल" कार्ड के साथ रिफिल किया जाता है।
बैंगनी रेखा, आधा खाली होने पर भरें : कार्ड यादृच्छिक रूप से तब तक खींचे जाते हैं जब तक कि डेक में 20 कार्ड न बचे हों; तब डेक 10 "सिर" कार्ड और 10 "पूंछ" कार्ड के साथ सबसे ऊपर है।
सियान लाइन, लगातार भरें : कार्ड यादृच्छिक पर खींचे जाते हैं; समान संख्या वाले ड्रॉ को तुरंत "हेड्स" कार्ड के साथ बदल दिया जाता है, और विषम-संख्या वाले ड्रॉ को "टेल्स" कार्ड के साथ बदल दिया जाता है।

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

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

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

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

— इल्मरी करोनें
स्रोत

बहुत विस्तृत जवाब। Dithering एल्गोरिथ्म में यादृच्छिक कारकों को जोड़ना सीधे आगे लगता है। :)

— सोनाटेन

अपने जवाब के साथ जाने का फैसला किया। :) लेकिन मैं आपको सलाह दूंगा कि आप विधि अवलोकन के परिवर्धन को सबसे ऊपर रखें। मैं आपके उत्तर के आधार पर क्या करने जा रहा हूं, "रेड" और "पर्पल" दोनों समाधानों का प्रयास करना है।

— सोनाटेन

53

पासा रोल न करें, कार्डों का सौदा करें।

अपने RNG के सभी संभावित परिणाम लें, उन्हें एक सूची में रखें, इसे यादृच्छिक रूप से फेरबदल करें, और यादृच्छिक क्रम में परिणाम वापस करें। जब आप सूची के अंत में हों, तो दोहराएं।

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

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

— फिलिप
स्रोत

1

— लुकिंग

3

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

— DMGregory

2

@DMGregory: वास्तव में, डेक खाली होने से पहले नए कार्ड में मिश्रण करना पूरी तरह से ठीक है (और, वास्तव में, मैं ऐसा करने के लिए परिणामों को अधिक प्राकृतिक और भविष्यवाणी करने के लिए कठिन बनाने की सलाह दूंगा)। महत्वपूर्ण बात यह सुनिश्चित करना है कि डेक में फेरबदल नए कार्ड का औसत (औसत) अंश वांछित अंश के बराबर होता है जिसे आप इसे बाहर निकालना चाहते हैं ।

— इल्मरी करोनें

4

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

— DMGregory

2

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

— वोल्ट

17

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

उदाहरण के लिए, आपके पास एक ग्राफ हो सकता है जो एक हमले के परिणाम (महत्वपूर्ण हिट, चकमा, आदि) का प्रतिनिधित्व करता है। खिलाड़ी के आँकड़ों को देखते हुए रैंडम नोड को प्रारंभिक रूप से उठाएं (केवल "पासा को रोल करें")। फिर, अगले हमले पर, तय करें कि आगे क्या होता है जिसे संक्रमण मॉडल दिया गया है।

संक्रमणों का वजन कैसे करें, यह तय करने के लिए देखभाल की आवश्यकता होती है। एक बात के लिए, एक नोड से निकलने वाले सभी संक्रमणों को एक संभाव्यता में जोड़ने की आवश्यकता होती है। 1. एक साधारण बात जो आप कर सकते हैं, वह प्रत्येक नोड से हर दूसरे नोड में एक संक्रमण बना सकती है, उन घटनाओं के बराबर वजन के साथ जो उन घटनाओं के होते हैं। एक प्राथमिकता , यह देखते हुए कि वर्तमान घटना फिर से नहीं हो सकती है।

उदाहरण के लिए, यदि आपके पास तीन घटनाएं हैं:

  Critical, P = 0.1
  Hit,      P = 0.3
  Miss,     P = 0.6

आप संक्रमण मॉडल को ऐसे सेट कर सकते हैं कि एक महत्वपूर्ण हिट बस फिर से इसकी संभावना द्रव्यमान को अन्य समरूपता में पुनर्वितरित करने से नहीं होती है:

  Critical -> Critical,   P = 0.0
  Critical -> Hit,        P = 0.35
  Critical -> Miss,       P = 0.65

EDIT: जैसा कि टिप्पणी नीचे कहा गया है, यह मॉडल वांछित व्यवहार प्राप्त करने के लिए पर्याप्त जटिल नहीं है। इसके बजाय, आपको कई अतिरिक्त राज्यों को जोड़ना पड़ सकता है!

— mklingen
स्रोत

1

आपके द्वारा प्रस्तावित पुनर्मूल्यांकन योजना प्रत्येक राज्य की वांछित संभावनाओं को संरक्षित नहीं करती है। इन नंबरों के साथ एक अनुभवजन्य परीक्षण करना, समय के 41% के बारे में याद आती है और क्रिटिकल के बारे में 25%, इनपुट मानों का रास्ता बंद हो जाता है। शेष राज्यों में संक्रमण उनकी संभावनाओं के अनुपात में होता है (जैसे कि मिस के पास क्रिट में जाने का 25% मौका है और हिट में जाने का 75% मौका) 44% मिस रेट और 17% क्रिट के साथ थोड़ा बेहतर है, लेकिन यह अभी भी है इनपुट में वांछित संभावनाओं का प्रतिबिंब नहीं।

— DMGregory

मैं Bayes शासन :( बाद में फिर से पुनर्गणना होगा भूल गया यह पूर्व संभावना वितरण बनाए रखने के लिए संभव नहीं हो सकता क्योंकि संक्रमण मॉडल के रूप में इसे बाहर CCHM या CHHM या बहुत संभावना MMHM आदि जैसे संभावित दृश्यों पत्ते खड़ा है।

— mklingen

"कोई दोहराता नहीं है" बाधा आपके हाथों को यहाँ पर बाँध सकती है, अत्यधिक उच्च और निम्न भार के संबंध में। यदि आप क्रिटिकल होने के लिए 10 में से 1 प्रयास चाहते हैं, तो यह एकमात्र तरीका है जो 5 मिसेस और 5 हिट को वैकल्पिक कर सकता है, जो हिट और मिस की संभावनाओं को उनके औसत की ओर बढ़ाता है। लगातार याद किए बिना कोई भी अनुक्रम यहां इनपुट की आवश्यकताओं को पूरा नहीं कर सकता है।

— DMGregory

4

@mklingen, मैं DMGregory से सहमत हूं, "सख्ती से कोई दोहराता नहीं है" यहां वांछनीय नहीं है। बल्कि, वे चाहते हैं कि समान परिणाम की लंबी श्रृंखलाओं की संभावना एक समान यादृच्छिक संभावना के साथ कम होने की संभावना है। आप एक मार्कोव चेन (जो निर्देशित है) के साथ ऐसा कर सकते हैं जो इस तरह दिखता है । यह कई राज्यों को बार-बार होने वाली घटनाओं का प्रतिनिधित्व करने के लिए उपयोग करता है जहां "हिट 1" से "हिट 2" और "हिट 2" से "हिट 3+" तक संक्रमण की संभावनाएं कम हो जाती हैं और "हिट 1" और "क्रिट" को वापस बदलने की संभावनाएं। 1 ”ऊपर जाएं।

— nwellcome

@nwellcome यह एक महान विचार है।

— mklingen

3

यहाँ एक कार्यान्वयन है जो मैंने C # में बनाया है:

संभावनाओं के आधार पर घटनाओं को सक्रिय करें
आवर्ती घटनाओं की संभावना को कम करने के लिए उन संभावनाओं को समायोजित करें
मूल संभावनाओं से बहुत दूर नहीं

मैंने कुछ टिप्पणियां जोड़ी हैं ताकि आप देख सकें कि मैं क्या कर रहा हूं।

    int percentageEvent1 = 15; //These are the starter values. So given a scenario, the
    int percentageEvent2 = 40; //player would have around a 15 percent chance of event
    int percentageEvent3 = 10; //one occuring, a 40 percent chance of event two occuring
    int percentageEvent4 = 35; //10 percent for event three, and 35 percent for event four.

    private void ResetValues()
    {
        percentageEvent1 = 15;
        percentageEvent2 = 40;
        percentageEvent3 = 10;
        percentageEvent4 = 35;
    }

    int resetCount = 0; //Reset the probabilities every so often so that they don't stray too far.

    int variability = 1; //This influences how much the chance of an event will increase or decrease
                           //based off of past events.

    Random RandomNumberGenerator = new Random();

    private void Activate() //When this is called, an "Event" will be activated based off of current probability.
    {
        int[] percent = new int[100];
        for (int i = 0; i < 100; i++) //Generate an array of 100 items, and select a random event from it.
        {
            if (i < percentageEvent1)
            {
                percent[i] = 1; //Event 1
            }
            else if (i < percentageEvent1 + percentageEvent2)
            {
                percent[i] = 2; //Event 2
            }
            else if (i < percentageEvent1 + percentageEvent2 + percentageEvent3)
            {
                percent[i] = 3; //Event 3
            }
            else
            {
                percent[i] = 4; //Event 4
            }
        }
        int SelectEvent = percent[RandomNumberGenerator.Next(0, 100)]; //Select a random event based on current probability.

        if (SelectEvent == 1)
        {
            if (!(percentageEvent1 - (3 * variability) < 1)) //Make sure that no matter what, probability for a certain event
            {                                                //does not go below one percent.
                percentageEvent1 -= 3 * variability;
                percentageEvent2 += variability;
                percentageEvent3 += variability;
                percentageEvent4 += variability;
            }
        }
        else if (SelectEvent == 2)
        {
            if (!(percentageEvent2 - (3 * variability) < 1))
            {
                percentageEvent2 -= 3 * variability;
                percentageEvent1 += variability;
                percentageEvent3 += variability;
                percentageEvent4 += variability;
            }
        }
        else if (SelectEvent == 3)
        {
            if (!(percentageEvent3 - (3 * variability) < 1))
            {
                percentageEvent3 -= 3 * variability;
                percentageEvent1 += variability;
                percentageEvent2 += variability;
                percentageEvent4 += variability;
            }
        }
        else
        {
            if (!(percentageEvent4 - (3 * variability) < 1))
            {
                percentageEvent4 -= 3 * variability;
                percentageEvent1 += variability;
                percentageEvent2 += variability;
                percentageEvent3 += variability;
            }
        }

        resetCount++;
        if (resetCount == 10)
        {
            resetCount = 0;
            ResetValues();
        }

        RunEvent(SelectEvent); //Run the event that was selected.
    }

आशा है कि यह मदद करता है, कृपया टिप्पणियों में इस कोड में सुधार का सुझाव दें, धन्यवाद!

— Superdoggy
स्रोत

1

यह पुन: लोड करने वाली योजना घटनाओं को नेतृत्व करने योग्य बनाती है। समय-समय पर वजन को रीसेट करना वास्तव में सिर्फ एक बैंड-सहायता है जो इसे कितना खराब हो जाता है, जबकि यह सुनिश्चित करना कि 10 में से 1 रोल को फिर से वजन करने से कोई लाभ नहीं मिलता है। इसके अलावा, एक एल्गोरिथ्म नोट: आप अपने यादृच्छिक चयन करने के लिए 100 प्रविष्टियों की तालिका भरकर बहुत सारे काम बर्बाद कर रहे हैं। इसके बजाय, आप एक यादृच्छिक रोल उत्पन्न कर सकते हैं और फिर अपने 4 परिणामों पर पुनरावृति कर सकते हैं, जैसे ही आप जाते हैं, उनकी संभावनाओं को जोड़ दें। जैसे ही रोल राशि से कम होता है, आपके पास आपका परिणाम होता है। कोई तालिका-भरने की आवश्यकता नहीं है।

— DMGregory

3

मुझे mklingen के उत्तर को थोड़ा सामान्य करने दीजिए । मूल रूप से, आप जुआरी के पतन को लागू करना चाहते हैं , हालांकि मैं यहां एक अधिक सामान्य विधि प्रदान करूंगा:

कहते हैं कि nसंभाव्यता के साथ संभावित घटनाएं होती हैं p_1, p_2, ..., p_n। जब घटना iहुई, तो इसकी संभावना एक कारक के साथ पुनर्विक्रय होगी 0≤a_i≤1/p_i(उत्तरार्द्ध महत्वपूर्ण है, अन्यथा आप एक से अधिक संभावना के साथ समाप्त हो जाते हैं और अन्य घटनाओं में नकारात्मक संभावनाएं होनी चाहिए , जिसका मूल रूप से " विरोधी " -विरोधी या कुछ और होता है), हालांकि। आम तौर पर a_i<1। आप उदाहरण के लिए चुन सकते हैं a_i=p_i, जिसका अर्थ है कि दूसरी बार घटित होने वाली घटना की संभावना है मूल संभावना है कि घटना लगातार दो बार हो रही है, उदाहरण के लिए एक दूसरे सिक्के के टॉस में 1/2 के बजाय 1/4 की संभावना होगी। दूसरी ओर, आपके पास कुछ भी हो सकते हैं a_i>1, जिसका अर्थ होगा "भाग्य / दुर्भाग्य का आघात"।

अन्य सभी घटनाएँ एक-दूसरे के सापेक्ष समान रूप से संभावित रहेंगी, अर्थात उन सभी को एक ही कारक से अलग करना होगा, b_iजैसे कि सभी संभावनाओं का योग एक बराबर होता है, अर्थात

1 = a_i*p_i + b_i*(1-p_i)  # Σ_{j≠i) p_j  = 1 - p_i
⇒ b_i = (1 - a_i*p_i) / (1 - p_i).   (1)

अब तक, इतना सरल। लेकिन अब एक और आवश्यकता जोड़ते हैं: दो घटनाओं के सभी संभावित अनुक्रमों को ध्यान में रखते हुए, वहां से निकाली गई एकल घटना संभावनाएं मूल संभावनाएं होंगी।

चलो

        / p_i * b_i * p_j  (j≠i)
p_ij = <
        \ a_i * (p_i)²     (j=i)

घटना के jबाद होने वाली घटना की संभावना को निरूपित करें iऔर ध्यान दें कि p_ij≠p_jiजब तक b_i=b_j (2)(जिसका (1)अर्थ है a_j = 1 - a_i*p_i + (1-a_i)*p_i/p_j)। यह वह भी है जो बेयस प्रमेय की आवश्यकता है और इसका अर्थ भी है

Σ_j p_ij = p_i * b_i * (1 - p_i) + a_i * (p_i)²
         = b_i * p_i + (a_i - b_i) * (p_i)²
         = p_i  # using (1)

बस के रूप में वांछित। बस ध्यान दें कि इसका मतलब कैसे एक दूसरे को a_iठीक करता है।

अब देखते हैं कि जब हम इस प्रक्रिया को कई बार लागू करते हैं, तो तीन या अधिक घटनाओं के अनुक्रम के लिए क्या होता है। मूल रूप से तीसरे ईवेंट की धांधली की संभावनाओं के लिए दो विकल्प हैं:

क) पहली घटना और रिग के बारे में भूल जाइए जैसे कि केवल दूसरी घटना हुई है, यानी

         / p_ij * a_j * p_j  (j=k)
p_ijk = <
         \ p_ij * b_j * p_l  (j≠k)

ध्यान दें कि यह आमतौर पर बेयस का उल्लंघन करता है, उदाहरण p_jik≠p_ikjके लिए ज्यादातर मामलों में।

बी) नई संभावनाओं के रूप में संभावनाओं p_ij(निश्चित के लिए ) का उपयोग करें जिससे आप आगे होने वाली घटना के लिए नई संभावनाएं प्राप्त करते हैं । आप संशोधित करते हैं या नहीं यह आपके ऊपर है, लेकिन ध्यान रखें कि संशोधित होने के कारण नए निश्चित रूप से अलग हैं । फिर, एक ही संभावना के साथ होने की सभी क्रमपरिवर्तन की आवश्यकता के द्वारा , का चुनाव संभवतया प्रतिबंधित है । चलो देखते हैं...ipi_jpi_jkkai_jbi_jpi_jai_jijk

         / p_ij * bi_j * pi_k  (j≠k)
p_ijk = <
         \ (p_ij)² * ai_j      (j=k)

         / b_i * bi_j * p_i * p_j * pi_k  (i≠j≠k≠i)
         | b_i * ai_j * p_i * (p_j)²      (i≠j=k)
      = <  a_i * (p_i)² * bi_i * pi_k     (i=j≠k)
         | b_i * p_i * bi_j * p_k * pi_i  (i=k≠j)
         \ a_i * ai_i * (p_i)² * pi_i     (i=k=j)

और संबंधित मामलों के लिए समान होना चाहिए।

मुझे डर है कि इस पर मेरी निरंतरता को थोड़ी देर इंतजार करना होगा ...

— टोबियास किंजलर
स्रोत

अनुभवजन्य रूप से परीक्षण, यह अभी भी कई रन से अधिक इनपुट संभावनाओं से दूर एक विरूपण में परिणाम है। यदि a_i / p_i = 0.5 उदाहरण के लिए, (और mklingen के उत्तर से संख्याओं का उपयोग करके) 60% की इनपुट मिस दर 50.1% की एक मनाया दर बन जाती है, और 10% की इनपुट महत्वपूर्ण दर 13.8% के रूप में देखी जाती है। आप परिणामी रूपांतरण मैट्रिक्स को उच्च शक्ति पर ले जाकर इसे सत्यापित कर सकते हैं। A_i का अनुपात चुनना: p_i कम विरूपण में 1 परिणाम के करीब है, लेकिन रन कम करने में कम प्रभावशीलता भी है।

— DMGregory

@DMGregory अच्छी बात: आप केवल ट्रांज़िशन मैट्रिक्स की शक्तियाँ नहीं ले सकते। मैं अपने उत्तर पर बाद में विस्तार करूंगा

— टोबियास किंजलर

@DMGregory मैंने पूरी प्रक्रिया (संस्करण b) का वर्णन करना शुरू कर दिया है, लेकिन यह काफी थकाऊ है और मैं वर्तमान में समय पर छोटा हूं: /

— टोबियास किंजलर

1

मुझे लगता है कि सबसे अच्छा विकल्प यादृच्छिक-भारित आइटम चयन का उपयोग करना है। यहां C # के लिए एक कार्यान्वयन है , लेकिन उन्हें आसानी से पाया जा सकता है या अन्य भाषाओं के लिए भी बनाया जा सकता है।

विचार यह होगा कि हर बार चुने जाने के बाद एक विकल्प का वजन कम किया जाए, और हर बार इसे उठाया न जाए।

उदाहरण के लिए, यदि आप द्वारा उठाए गए विकल्प के वजन को घटाते हैं NumOptions-1और हर दूसरे विकल्प का वजन 1 से बढ़ाते हैं (वजन के साथ वस्तुओं को हटाने के लिए सावधान रहें <और 0 से ऊपर उठने पर उन्हें पढ़ें) , तो हर विकल्प लगभग चुना जाएगा लंबी अवधि में एक ही समय में, लेकिन हाल ही में चुने गए विकल्पों को चुनने की संभावना बहुत कम होगी।

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

— ब्लूराजा - डैनी पफ्लुघोफ़्ट
स्रोत

1

मेरा उत्तर गलत है, मेरा परीक्षण त्रुटिपूर्ण था।

मैं इस उत्तर को चर्चा और टिप्पणियों के लिए छोड़ रहा हूं जो इस डिजाइन की खामियों को इंगित करते हैं, लेकिन वास्तविक परीक्षण गलत था।

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

इसे पूरा करने का सबसे आसान तरीका है कि प्रत्येक रोल के लिए सभी वज़न को बदलकर विशिष्ट मूल्य के लिए वज़न घटाकर और दूसरे वज़न को बढ़ाकर ।

एक उदाहरण के रूप में, आपको 4 वेट्स कहते हैं: फ़ंबल, मिस, हिट और क्रिट। यह भी कहना है कि उनके लिए आपका वांछित कुल वजन Fumble = 10%, मिस = 50%, हिट = 30%, और क्रिट = 10% है।

यदि आप 1 और 100 के बीच मान उत्पन्न करने के लिए एक यादृच्छिक संख्या जनरेटर (RNG) का उपयोग करते हैं, और फिर उस मान की तुलना इस श्रेणी में करते हैं (1-10 Fumble, 11-60 मिस, 61-90 हिट, 91-100 crit ), आप एक व्यक्तिगत रोल तैयार कर रहे हैं।

यदि, जब आप उस रोल को बनाते हैं, तो आप तुरंत उन श्रेणियों को रोल किए गए मान के आधार पर समायोजित कर लेते हैं, आप भविष्य के रोल का वेटिंग करेंगे, लेकिन आपको उसी कुल राशि से रोल किए गए वजन को कम करने की भी आवश्यकता होती है जिसे आप अन्य वज़न बढ़ाते हैं। तो ऊपर हमारे उदाहरण में, आप 3 से लुढ़का हुआ वजन कम करेंगे और अन्य वजन को 1 से बढ़ा देंगे।

यदि आप प्रत्येक रोल के लिए ऐसा करते हैं, तब भी आपके पास लकीरों का मौका होगा, लेकिन वे बहुत कम हो जाएंगे, क्योंकि प्रत्येक रोल के लिए आप इस संभावना को बढ़ा रहे हैं कि भविष्य के रोल वर्तमान रोल के अलावा कुछ और होंगे। आप इस प्रभाव को बढ़ा सकते हैं, और इस प्रकार आगे चलकर लकीरों की संभावना को कम कर सकते हैं, एक बड़े कारक द्वारा भार को घटा / घटाकर (जैसे 6 से वर्तमान को कम कर सकते हैं और अन्य को 2 से बढ़ा सकते हैं)।

मैंने इस दृष्टिकोण को मान्य करने के लिए एक त्वरित ऐप चलाया, और उन भार के साथ 32000 पुनरावृत्तियों के बाद, यह निम्नलिखित रेखांकन पैदा करता है। ऊपरी ग्राफ़ प्रत्येक रोल पर 4 वज़न तत्काल मान दिखाता है, और निचला ग्राफ़ उस बिंदु पर रोल किए गए प्रत्येक प्रकार के परिणाम की कुल संख्या दिखाता है।

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

ध्यान दें कि यह उदाहरण .NET System.Random क्लास का उपयोग करके बनाया गया था, जो वास्तव में वहाँ से बाहर बेहतर RNG में से एक नहीं है, इसलिए आप शायद बेहतर RNG का उपयोग करके अधिक सटीक परिणाम प्राप्त कर सकते हैं। यह भी ध्यान दें कि 32000 अधिकतम परिणाम थे जो मैं इस उपकरण के साथ ग्राफ कर सकता था, लेकिन मेरा परीक्षण उपकरण समान समग्र पैटर्न के साथ 500 मिलियन से अधिक परिणाम उत्पन्न करने में सक्षम था।

— डेविड सी एलिस
स्रोत

ध्यान दें कि यह केवल तभी काम करता है जब आपके + 1s / -3 s मूल वजन के सापेक्ष लगाए जाते हैं, बल्कि हाल ही में उपयोग किए गए भार के बजाय। (लगातार वज़न को समान रूप से संशोधित करना इस तरह उन्हें परिवर्तनशील होने की दिशा में बहाव बनाता है)। हालांकि यह लंबे समय तक लक्ष्य को बनाए रखता है, लेकिन यह रन कम करने के लिए बहुत कम करता है। यह देखते हुए कि मैंने एक बार मिस किया है, एक पंक्ति में दो बार और याद करने का मौका इस योजना के साथ 22% है, बनाम 25% स्वतंत्र ड्रॉ के साथ। एक बड़े प्रभाव के लिए वेट शिफ्ट बढ़ाना (+ 3 / -9 कहना) लंबे समय तक चलने की संभावना को कम करने का परिणाम है।

— DMGregory

वास्तव में ऊपर प्रस्तुत किया गया डेटा + 1 / -3 को सबसे हाल के वजन पर लागू कर रहा है जब प्रत्येक बार एक रोल संसाधित होता है। इसलिए यदि आप शुरुआती 50% वजन में एक बार चूक जाते हैं, तो अगला मिस वजन 47% होगा, और यदि आप फिर से याद करते हैं, तो निम्न वजन 44% होगा, और इसी तरह। यह रन कम करता है (अलग-अलग मीट्रिक रन को ट्रैक कर रहा था, रन में 24% की कमी के रूप में पाया गया), लेकिन वे अभी भी अपरिहार्य हैं क्योंकि इस योजना में अभी भी 4 में से प्रत्येक को गैर-शून्य संभावना के साथ छोड़ने का एक मजबूत मौका है ( उदाहरण के लिए, एक पंक्ति में चार अपराध घटित होने के शून्य अवसर के साथ आलोचकों के वजन को छोड़ देते हैं)।

— डेविड सी एलिस

यदि वह आपकी मंशा थी, तो आपके कार्यान्वयन में एक बग है। ग्राफ को देखें - फंबल का वजन केवल 7 और 11 के बीच कभी भी उछलता है, जिसके बाहर कोई मूल्य नहीं है। मैंने आपके द्वारा वर्णित निरंतर संशोधन का उपयोग करके एक सिमुलेशन चलाया, और ग्राफ़ में काफी भिन्नता है, प्रत्येक राज्य की संभावनाओं के साथ पहले सौ परीक्षणों में प्रत्येक 25% की ओर परिवर्तित होता है।

— DMGregory

खतरे के रूप में, वास्तव में यह आपके द्वारा इंगित किए जाने के कारण खराब हो गया था। खैर, इस उत्तर पर प्रहार कीजिए।

— डेविड सी एलिस

@DavidCEllis क्या आप कह रहे हैं कि आपका कार्यान्वयन त्रुटिपूर्ण था, या यह विचार स्वयं है? मेरे बैक-ऑफ-द-नैपकिन अंतर्ज्ञान मोटे तौर पर आपके द्वारा वर्णित मॉडल का वर्णन करता है (खींचे जाने पर एक संभावना को समायोजित करें, धीरे-धीरे समय के साथ अपने मूल मूल्यों के लिए सभी संभावनाओं को बहाल करें) और यह अभी भी मेरे लिए समझ में आता है।

— dimo414

0

आप वह कर सकते हैं जो अनिवार्य रूप से एक फिल्टर है। पिछले n घटनाओं का ध्यान रखें। संभावना उन घटनाओं पर लागू कुछ फिल्टर में से कुछ है। 0 फ़िल्टर आधार संभावना है, यदि 0 तो आपने चकमा दे दिया, यदि 1 आप विफल रहे। मान लें कि आधार 25% था, और फ़िल्टर प्रत्येक पुनरावृत्ति में आधा घट गया। आपका फ़िल्टर तब होगा:

[.25 .125 .0625 .03125]

यदि आप चाहें तो जारी रखने के लिए स्वतंत्र महसूस करें। इस योजना की समग्र संभावना .25 की आधार संभावना से थोड़ी अधिक है। वास्तव में, संभाव्यता, एक ही योजना दी गई है, (मैं x को वास्तविक संभाव्यता कह रहा हूं, p संभाव्यता इनपुट है):

x=p+(1-x)*(p/2+p/4+p/8)

एक्स के लिए हल करने पर एक पाता है जवाब है p(1+1/2+1/4+1/8)/(1+p(1/2+1/4+1/8), या हमारी दिया मामले के लिए, x=0.38461538461। लेकिन जो आप वास्तव में चाहते हैं वह है पी, दी गई एक्स। यह एक अधिक कठिन समस्या है। यदि आप एक अनंत फ़िल्टर मान लेते हैं, तो समस्या बन जाती है x+x*p=2*p, या p=x/(2-x)। तो अपने फ़िल्टर को बढ़ाते हुए, आप फिर एक नंबर p के लिए हल कर सकते हैं जो औसतन आपको एक ही परिणाम देगा, लेकिन एक दर पर निर्भर करता है कि हाल ही में कितनी सफलता मिली है।

मूल रूप से, आप पिछले मानों का उपयोग यह निर्धारित करने के लिए करते हैं कि स्वीकृति सीमा क्या है यह दौर है, और एक यादृच्छिक मान लें। फिर फ़िल्टर को देखते हुए अगले यादृच्छिक मूल्य का उत्पादन करें।

— PearsonArtPhoto
स्रोत

-1

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

यहाँ जावा में इसे लागू किया गया है।

import java.util.Map;
import java.util.Random;

/**
 * A psuedorandom weighted outcome generator
 * @param <E> object type to return
 */
public class WeightedRandom<E> {

    private Random random;
    private Map<E, Double> weights;

    public WeightedRandom(Map<E, Double> weights) {
        this.random = new Random();
        this.weights = weights;
    }

    /**
     * Returns a random outcome based on the weight of the outcomes
     * @return
     */
    public E nextOutcome() {
        double totalweight = 0;

        // determine the total weigth
        for (double w : weights.values()) totalweight += w;

        // determine a value between 0.0 and the total weight
        double remaining = random.nextDouble() * totalweight;

        for (E entry : weights.keySet()) {
            // subtract the weight of this entry
            remaining -= weights.get(entry);

            // if the remaining is smaller than 0, return this entry
            if (remaining <= 0) return entry;
        }

        return null;
    }

    /**
     * Returns the weight of an outcome
     * @param outcome the outcome to query
     * @return the weight of the outcome, if it exists
     */
    public double getWeight(E outcome) {
        return weights.get(outcome);
    }

    /**
     * Sets the weight of an outcome
     * @param outcome the outcome to change
     * @param weight the new weigth
     */
    public void setWeight(E outcome, double weight) {
        weights.put(outcome, weight);
    }
}

EDIT उस स्थिति में जहां आप वेट को अपने आप एडजस्ट करना चाहते हैं, उदाहरण के लिए A का मौका बढ़ाएं जब परिणाम B था। आप या तो,

nextOutcome()विधि के व्यवहार को बदलें , इसलिए यह परिणाम के अनुसार वजन को संशोधित करता है
setWeight()परिणाम के अनुसार वजन को संशोधित करने के लिए उपयोग करें ।

— erikgaal
स्रोत

मुझे लगता है कि आपने प्रश्न को गलत समझा होगा: ओपी यह नहीं पूछ रहा है कि भारित यादृच्छिक परिणाम कैसे उत्पन्न किए जाएं, लेकिन एक ही परिणाम की संभावना को कम करने के लिए भार को कैसे समायोजित किया जाए, कई बार।

— इल्मरी करोनें

मैं देख रहा हूँ, मैंने अपने कुछ उत्तर को यह समझाने के लिए बदल दिया है कि इस प्रणाली का उपयोग कैसे संभव होगा।

— एरिकागेल