विकल्प चुनने के लिए एक सरल छद्म यादृच्छिक एल्गोरिदम

इस पोस्ट में मैं पहले से किए गए विकल्पों के आधार पर एक सरल प्रस्ताव एल्गोरिथ्म के बारे में बात करना चाहता हूं। इसके लिए, सबसे पहले, हम दो कार्य करते हैं:

1. सरणी से यादृच्छिक मान का चयन करें
2. मूल्यों के वजन के आधार पर सरणी से यादृच्छिक मान का चयन करें

निश्चित रूप से कई नोटिस करेंगे कि पहली समस्या को हल करने के लिए, कई पीएल में तैयार कार्य हैं। हालांकि, मैं दूसरी समस्या को हल करने के लिए एक क्रमिक दृष्टिकोण के लिए, इसे अलग तरीके से हल करने के लिए साइकिल के साथ आऊंगा।



समाधान के लिए, मैं जावास्क्रिप्ट के समान कुछ हद तक छद्मकोड का उपयोग करूंगा। इसलिए, मेरी यादृच्छिक () विधि 0 से 1 तक मान लौटाएगी।

तो, कार्य 1

आप बस प्रत्येक पुनरावृत्ति पर सरणी पर पुनरावृत्ति कर सकते हैं, बेतरतीब ढंग से सच / गलत हो रही है, तो आप प्रपत्र के सामान्य जावास्क्रिप्ट समाधान का उपयोग कर सकते हैं। Math.floor(Math.random() * maxNumber)



, जो, वैसे, समाधान का छोटा संस्करण है जिसका मैं उपयोग करूंगा।

निर्णय

बराबर n



खंडों से 0 से 1 तक की संख्या को विभाजित करें और random



से निकटतम पिछला मान लें:

व्यावहारिक हिस्सा

सादगी के लिए, हम केवल अपने स्वयं के सूचकांक वाले 150 तत्वों की एक सरणी लेते हैं। यानी 0 से 150 तक की एक संख्या श्रृंखला।

 maxNumber = 150; //      elementPart = 100 / maxNumber / 100; //     ,     0.66% randomResult = random(); cursor = 0; for (i = 0; i <= maxNumber; i++) { cursor += elementPart; if (cursor >= randomResult) { result = i; break; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

टास्क २

हम कुछ प्रारंभिक डेटा पेश करते हैं:

 items = [ {id: 1, score: 4}, {id: 2, score: 0}, {id: 3} ]
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जहां score



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

चौकस पाठक यह ध्यान देने में कामयाब रहा कि 0 अंक डिफ़ॉल्ट मान नहीं है। ऐसा इसलिए किया जाता है ताकि नमूने से मूल्य को बाहर करना संभव हो, इसलिए, अंकों की डिफ़ॉल्ट संख्या को 1 के रूप में लिया जाएगा। ऐसा करने के लिए, हम प्रारंभिक डेटा को सही करेंगे:

 for (i = 0; i < items.length; i++) { item = items[i]; if (item.score === 0) { item.remove(); //     continue; } if (item.score === null) { item.score = 1; //  score ,    1 } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

निर्णय

समाधान का सार मान के खंडों को 0 से 1 तक की श्रेणी में बदलना है।

एक उदाहरण:

व्यावहारिक हिस्सा

मूल्य के वजन गणना जोड़ें:

 sumScores = 0; for (i = 0; i < items.length; i++) { //     sumScores += items[i].score; } for (i = 0; i < items.length; i++) { weight = items[i].score / sumScores; items[i].weight = weight; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यहां, वजन सभी तत्वों के कुल बिंदुओं का एक प्रतिशत है।

हम वजन की राशि की गणना करते हैं और समस्या के समाधान को अंतिम रूप देते हैं 1:

 sumWeights = 0 for (i = 0; i < items.length; i++) { //     sumWeights += items[i].weight; } cursor = 0; for (i = 0; i < items.length; i++) { cursor += items[i].weight / sumWeights; if (cursor >= randomResult) { suggestedItem = items[i]; break; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस प्रकार, हमें आईडी = 1 के साथ आईडी के साथ एक उच्च संभावना के साथ एक मूल्य मिलता है। 3. हालांकि, इस मामले में, जल्द या बाद में हम इस निष्कर्ष पर पहुंचेंगे कि समान मूल्यों की पेशकश की जाएगी (अंकों की संख्या में वृद्धि के अधीन) और जब तक, निश्चित रूप से, कृत्रिम रूप से उन्हें नमूने से बाहर न करें)।

ऐसा समाधान उन प्रणालियों पर काफी लागू होता है जहां उपयोगकर्ता को सबसे समान कुछ देने की आवश्यकता होती है - हम केवल आपकी पसंद के हिसाब से वांछित मानों (समान रंग, समान प्रकार, शायद एक ही निर्माता) के स्कोर की रचना करते हैं, स्कोर को 0 पर सेट करने के लिए चयनित मूल्य को बाहर करने के बिना भूल जाते हैं। ।

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

 for (i = 0; i < items.length; i++) { weight = 1 - items[i].score / sumScore; if (items[i].score == sumScore) { weight = 1; } items[i].weight = weight; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जहां वजन प्रतिशत के लिए औंधा मूल्य है।

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



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

इन दो दृष्टिकोणों को जोड़ा जा सकता है: उदाहरण के लिए, हम उपयोगकर्ता को एक निर्माता प्रदान करते हैं, जिसके उत्पाद वह आमतौर पर खरीदता है, लेकिन साथ ही हम ऐसे सामानों की पेशकश करते हैं जो उसने अभी तक नहीं खरीदे हैं।



आप यहां डेमो की कोशिश कर सकते हैं।

विषय द्वारा

विकल्पों के बहु-मापदंड विकल्प और फ़ज़ी विकल्प के नियमों के बारे में यहाँ पढ़ें।