दिलचस्प पोस्ट
बैच फ़ाइल में वेरिएबल के रूप में कमांड आउटपुट कैसे सेट करें सी ++ 11 में एक प्रकार का गैर-चलने कब बनायेगा? आईओएस प्रोग्राम को फोटो लेता है I क्या HTML पर 'onclick' पर .exe या .bat फ़ाइल चलाने संभव है सभी मॉड्यूल की सूची है जो अजगर पैकेज का हिस्सा हैं? अजगर में दो पंक्तियों के बीच कोण की गणना यदि == का उपयोग करते हुए बयान अप्रत्याशित परिणाम देता है .on () फ़ंक्शंस कॉल्स के बीच अंतर कर्ल PHP भेज छवि संपूर्ण एएससीआईआई फ़ाइल को सी ++ std :: स्ट्रिंग में पढ़ें संदर्भ असाइनमेंट परमाणु है इसलिए इंटरलॉक किया गया है। एक्सचेंज (रिज ऑब्जेक्ट, ऑब्जेक्ट) की आवश्यकता है? आत्मा अर्थ क्रिया में पैरामीटर प्रकारों का पता लगा रहा है सी में निश्चित पता चर एक मैट्रिक्स को 1 आयामी सरणी में कनवर्ट करें एसक्यूएल कैसे आरोही क्रमबद्ध करते समय शून्य मान बनाने के लिए आखिर में आते हैं

यादृच्छिक भारित विकल्प

मेरे पास इस तरह डेटा है:

d = ( (701, 1, 0.2), (701, 2, 0.3), (701, 3, 0.5), (702, 1, 0.2), (702, 2, 0.3), (703, 3, 0.5) ) 

कहां (701, 1, 0.2) = (आईडी 1, आईडी 2, प्राथमिकता)

अगर आईडी 1 को पता है, प्राथमिकता का उपयोग करते हुए क्या आईडी 2 को चुनने का एक बहुत अच्छा तरीका है?

Func (701) को वापस करना चाहिए:
1 – 20% मामलों में
2 – 30%
3 – 50%

प्रतिशत पाठ्यक्रम के किसी न किसी प्रकार का होगा

Solutions Collecting From Web of "यादृच्छिक भारित विकल्प"

प्रत्येक आईडी 1 के लिए एक संचयी वितरण समारोह उत्पन्न करें:

 cdfs = defaultdict() for id1,id2,val in d: prevtotal = cdfs[id1][-1][0] newtotal = prevtotal + val cdfs[id1].append( (newtotal,id2) ) 

तो आपके पास होगा

 cdfs = { 701 : [ (0.2,1), (0.5,2), (1.0,3) ], 702 : [ (0.2,1), (0.5,2) ], 703 : [ (0.5,3) ] } 

फिर एक यादृच्छिक संख्या उत्पन्न करें और सूची में इसके लिए खोज करें।

 def func(id1): max = cdfs[id1][-1][0] rand = random.random()*max for upper,id2 in cdfs[id1]: if upper>rand: return id2 return None 

यह समझते हुए कि मेरा पहला जवाब उसके गणित में काफी छोटी है, मैंने एक नया विचार पेश किया है। मेरा मानना ​​है कि यहां पर एल्गोरिथ्म कई अन्य उत्तरों के समान है, लेकिन यह कार्यान्वयन "सुंदर" (यदि वह बराबर है) प्रश्न के लिए योग्यता के लिए अर्हता प्राप्त करता है:

 def func(id): rnd = random() sum = 0 for row in d: if row[0] == id: sum = sum + row[2] if rnd < sum: return row[1] 

ओपी से उदाहरण के आंकड़ों के साथ यह इस तरह चला जाता है:

  • 0 और 1.0 के बीच एक यादृच्छिक संख्या चुनें
  • यदि संख्या < 0.2 , तो पहले तत्व वापस लौटें
  • अन्यथा यदि संख्या है < 0.5 वापस दूसरा तत्व
  • अन्यथा (यदि संख्या < 1.0 ) तो तीसरे तत्व को वापस लौटाएं

पर्याप्त मात्रा में मूल्यों पर यादृच्छिक मॉड्यूल से पृथक वर्दी वितरण का उपयोग करें, फिर इसे विभाजन करें:

उदाहरण के लिए, मामले के लिए 701 10 मानों पर एक वितरण का उपयोग करते हैं, 2 मानों के लिए रिटर्न 1, दूसरा 3, रिटर्न 2, और दूसरे 5, रिटर्न 3 के लिए।

आप पर्याप्त वर्दी वितरण का उपयोग कर किसी भी वितरण का निर्माण कर सकते हैं 🙂

यदि आपके प्रतिशत मान पूर्ण प्रतिशत मानों से अधिक सटीक नहीं होंगे, तो संख्या 0-99 उत्पन्न करने के लिए यादृच्छिक संख्या जनरेटर का उपयोग करें।

फिर अपने फ़ंक्शन में, सही संख्या चुनने के लिए (प्रोग्रामेटिक) मामलों का उपयोग करें। उदाहरण के लिए (इसे साफ़ करें):

 अगर 701
   अगर random_num <20
     वापसी 1
   और अगर यादृच्छिक संख्या <50 // (20 + 30)
     वापसी 2
   और अगर यादृच्छिक संख्या <100 // (20 + 30 + 50)
     वापसी 3
   अन्य
     // त्रुटि

बहुत तेज़ हैक:

 import random d = { 701: [(1,0.2),(2,0.3),(3,0.5)], 702: [(1,0.2),(2,0.3),(3,0.5)] } def func(value): possible_values=d[value] total=sum(p[-1] for p in possible_values) random_value=random.random() prob=possible_values[0][-1]/total index=1 while index<len(possible_values) and prob<random_value: prob+=possible_values[index][-1]/total index+=1 return possible_values[index-1][0] if __name__=='__main__': testcases=1000 cnt=[0,0,0] for case in xrange(testcases): answer=func(701) cnt[answer-1]+=1 for i in xrange(3): print "Got %d %f%% of the time"%(i+1,float(cnt[i])/testcases*100) 

यह सुंदर नहीं है, लेकिन यह पहली बात है जो मन में आया और उम्मीद के मुताबिक काम करने के लिए दिखाई देता है।

अंतराल [0,1] में यादृच्छिक मूल्य प्राप्त करने के लिए यह क्या होता है (यादृच्छिक। Random () का उपयोग करके) यह तब उपयोग करता है कि क्या यादृच्छिक मूल्य अंतराल [0,0.2], [0.20.5) या [0.51] में पड़ता है, यह पता लगाने के लिए कि वापस जाने के लिए कौन-सा मान है

दो विचार (मुझे विवाद के नामों में स्पष्टता की खातिर अलग विकल्प और अनुपात के साथ वर्णन करने की इजाजत देता है, यदि वे एक ट्यूपल में पैक कर रहे हैं तो आप "ज़िप" को बचा सकते हैं):

क) पूर्णांक अनुपात प्राप्त करने के लिए वजन को नरम करना, फिर कई प्रतियों के रूप में अनुपात के रूप में दर्ज करें और random.choice रूप से उपयोग random.choice

 def choice_with_ratios(options, ratios): tmp = sum([[v]*n for v, n in zip(options, ratios)], []) return random.choice(tmp) 

ख) सामान्य वजन का उपयोग करें और जब तक आप एक यादृच्छिक उत्पन्न वर्दी मूल्य तक नहीं पहुंचें, तब तक शुरू करें

 def choice_with_weights(options, weights): s = 0 r = random.random() for v, w in zip(options, weights): s += w if s >= r: break return v 

वैसे, यदि पहले फ़ील्ड को कुंजी के रूप में प्रयोग किया जाता है, तो आपको इसे एक शब्दकोश में रखना चाहिए, जैसे:

 d = { 701: ((1, 0.2), (2, 0.3), (3, 0.5), 702: ((1, 0.3), (2, 0.2), (3, 0.5) } 

आप प्रत्येक मान के लिए एक 100-तत्व सूची भी बना सकते हैं, और फिर यादृच्छिक.शोध को एक वरीयता प्राप्त सूची से चुनकर दें, जिनके सदस्यों को आपके द्वारा अपेक्षित भार में लोड किया गया है:

 import random from collections import defaultdict d = ( (701, 1, 0.2), (701, 2, 0.3), (701, 3, 0.5), (702, 1, 0.2), (702, 2, 0.3), (702, 3, 0.5) ) class WeightedLookup(object): def __init__(self, valueTupleList): self.valdict = defaultdict(list) for key, val, prob in valueTupleList: self.valdict[key] += [val]*(int)(prob*100) def __getitem__(self,key): return random.choice(self.valdict[key]) lookup = WeightedLookup(d) # test out our lookup distribution, sample it 100000 times res = { 1:0, 2:0, 3:0 } for i in range(100000): res[lookup[701]] += 1 # print how many times each value was returned for k in (1,2,3): print k, res[k] 

प्रिंटों:

 1 20059 2 30084 3 49857