चुनौतियों में यादृच्छिक पीढ़ी को निर्दिष्ट करने के तरीके


16

नोट : मेटा पर सहमति के अनुसार , प्रश्न यहाँ विषय पर हैं।

इस बात के प्रकाश में कि "चुनौतियों को लिखते समय बचने के लिए" , मैंने कुछ प्रकार की वस्तुओं की यादृच्छिक पीढ़ी को शामिल करने वाली चुनौतियों के बारे में सोचना शुरू किया।

कभी-कभी ऐसा होता है कि मैं एक चुनौती पोस्ट करना चाहता हूं जिसमें बेतरतीब ढंग से एक फू पैदा करना शामिल है, जहां

  1. यह जांचना बहुत आसान है कि क्या दी गई चीज एक फू है, और
  2. यह जल्दी से एक "अच्छी गुणवत्ता" यादृच्छिक फू उत्पन्न करने के लिए थोड़ा कठिन है।

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

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

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

एक अप्रत्याशित यादृच्छिक फू के लिए एक अच्छी सामान्य परिभाषा हो सकती है?

टी एल; डॉ

वहाँ एक "अप्रत्याशित" बेतरतीब ढंग से उत्पन्न वस्तु को निर्दिष्ट करने का एक अच्छा तरीका है जो वितरण को ठीक नहीं करता है लेकिन हार्ड-कोडिंग को हतोत्साहित करता है?


हमारे पास मेटा पर यादृच्छिक के लिए एक मानक परिभाषा है जो हार्ड-कोडिंग पर प्रतिबंध लगाएगा, लेकिन इसे अभी तक पूरी तरह से समान रूप से प्रतिबंधित नहीं किया गया है।
जियोबिट्स

5
बड़ा सवाल है। मैंने अतीत में पाया है कि यादृच्छिकता को निर्दिष्ट करना कठिन है । विशेष रूप से आपके द्वारा वर्णित परिदृश्य के लिए, वहाँ भी समस्या है कि आप यादृच्छिक उम्मीदवारों को उत्पन्न कर सकते हैं और यदि वे अमान्य हैं तो फिर से करें। यहां तक ​​कि आपको एक समान वितरण भी देता है, लेकिन गैर-नियतात्मक रनटाइम। जब समान वितरण को निर्दिष्ट वहाँ भी मुद्दा है कि वास्तविक समाधान कभी नहीं कर रहे हैं पूरी तरह से वर्दी। यह एक बहुत ही सूक्ष्म मुद्दा है। +1
मार्टिन एंडर

@MartinEnder राइट, मैं उस दृष्टिकोण को भूल गया। मैं इसे और अन्य धीमी एल्गोरिथ्म को समय सीमा के साथ समाप्त कर सकता हूं, लेकिन वे अभी भी "एक हार्ड-कोडेड फू" समाधान की अनुमति देते हैं।
जर्ग डेब

ऐसा लगता है कि आप K3 / K4 CPRNG को निर्दिष्ट कर सकते हैं, अधिकांश भाषाओं में एक पुस्तकालय होगा। en.wikipedia.org/wiki/Pseudorandom_number_generator
Ewan

1
@Zbb को "Generate and redo" को अस्वीकार करने के साथ एक बड़ी समस्या यह है कि भाषा के RNG पुस्तकालयों का बहुमत सिर्फ इतना ही है।
नाथन मेरिल

जवाबों:


5

एक हजार अलग-अलग फू ल लौटाओ

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

जन्मदिन के विरोधाभास से अवगत रहें , कि आपके विचार से डुप्लिकेट की संभावना अधिक हो सकती है। यदि केवल एक लाख संभावित फॉस हैं, तो एक हज़ार यादृच्छिक फ़ॉस्स में लगभग 0.6 की संभावना होगी कि वहाँ कहीं एक डुप्लिकेट है, और यह मानते हुए कि फू पीढ़ी पूरी तरह से समान है। यदि यह एक समस्या हो सकती है, तो प्रत्येक 1000 उत्पन्न के लिए 900 अद्वितीय फ़ॉज़ की आवश्यकता होती है, जो कि वास्तविक फू जनरेटर के लिए अधिक उदार है, लेकिन हार्डकोडिंग के लिए अव्यवहारिक है।

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

इसे जल्दी करो

पूरी तरह से यादृच्छिक फू-जैसी चीज की संभावनाएं बहुत कम हैं, इसलिए समय सीमा को निर्दिष्ट करने से फू पीढ़ी में वास्तविक प्रयास के लिए मजबूर होने की संभावना है।

अलग-अलग भाषाओं के बीच गति अंतर को समायोजित करने के लिए, आप हैकर्रानक जैसी भाषा के आधार पर अलग-अलग समय सीमाएं चाहते हो सकते हैं: https://www.hackerrank.com/environment । हालाँकि यदि आप बड़े पैमाने पर पर्याप्त मात्रा में निर्दिष्ट करते हैं तो रैंडम फू-जैसी चीजें होने की संभावना बहुत कम हो सकती है, इसलिए "यूनिवर्स की हीट डेथ से पहले" नियम पर्याप्त हो सकता है।


मुझे लगता है कि आप यहाँ पर हैं। "प्रोग्राम को चलाने से एन बार कम से कम 90% समय तक कोई डुप्लिकेट उत्पन्न नहीं करेगा" ठोस और परीक्षण के लिए बहुत आसान है, और इसे ब्रूट फोर्सिंग और सरल अस्वीकृति नमूने को रोकने के लिए बाध्य समय के साथ भी जोड़ा जा सकता है।
जर्ग डेब

2

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

समाधान नहीं: हार्ड-कोडिंग को स्पष्ट रूप से अस्वीकार करें

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

हार्ड-कोडिंग को प्रभावी बनाएं

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

आउटपुट को परिमाणित करें

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

रखो कुछ संभावना वितरण पर प्रतिबंध

यदि आप पूरी तरह से अप्रतिबंधित संभावना वितरण को छोड़ने के लिए तैयार हैं , तो आप इस पर कुछ अड़चनें डाल सकते हैं, जो अभी भी उत्तरदाताओं को उनके वितरण को चुनने में बहुत अधिक स्वतंत्रता देते हैं, लेकिन जो कठिन-कोडिंग को कठिन या असंभव बनाते हैं:

  • सबसे सरल बाधा जो मन में आती है, वह यह है कि किसी भी संभावित आउटपुट के लिए न्यूनतम और अधिकतम संभाव्यता के बीच अंतर को एक निश्चित सीमा से कम होना चाहिए। एक हार्ड-कोडित दृष्टिकोण की संभावना लगभग सभी आउटपुट के लिए लगभग-शून्य संभावनाएं और डिफ़ॉल्ट मान के लिए 1 के करीब संभावना होगी। यदि आपको अधिकतम अंतर 0.1 से नीचे होने की आवश्यकता है, तो दृष्टिकोण को एक विकल्प बनाने के लिए 10 (यादृच्छिक रूप से चुने गए) डिफ़ॉल्ट मानों की आवश्यकता होगी। इसी तरह आपको प्रत्येक संभावित आउटपुट के लिए न्यूनतम संभावना की भी आवश्यकता हो सकती है, जैसे 1 / (2 * N *), जहां N संभव आउटपुट की संख्या है।
  • वैकल्पिक रूप से, आप की आवश्यकता हो सकती वितरण में कोई (संभावना) अंतराल देखते हैं कि, आकार का कोई अंतराल नहीं है ताकि δ (आपके द्वारा चुने गए) ऐसा है कि दोनों उच्च और निम्न संभावनाओं मौजूद हैं। इसका मतलब यह है कि संभावना की दृष्टि से कोई भी आउटलेयर नहीं हो सकता है, जो कि हार्ड-कोडिंग दृष्टिकोण द्वारा उत्पन्न होता है।

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

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

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.