एक बटन के पुश द्वारा ड्रा करें

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

1. इसमें भाग लेने वाली टीमें हैं।
2. पहले दौर की प्रत्येक टीम एन -1 मैच खेलेगी।
3. टीम N किसी भी दौर में अपने दम पर नहीं खेल सकती।
4. प्रत्येक दौर में, प्रतिद्वंद्वी अद्वितीय, गैर-दोहराए जाने वाले जोड़े बनाते हैं।
5. यदि एक दौर में, टीम N टीम M के साथ खेलती है, तो क्रमशः, उसी दौर में, टीम M टीम N के साथ खेलती है।

दो-आयामी ड्राटेबल [i, j] सरणी को यादृच्छिक चर के साथ भरने की प्रक्रिया के साथ प्रतिद्वंद्वियों के यादृच्छिक जोड़े बनाने की प्रक्रिया की तुलना करते हुए, मुझे निम्नलिखित (C #, .Net 4.0 भाषा) मिली:

1. एक निश्चित सीमा से टीम एन चुनें (इस संस्करण में, उन्हें चैंपियनशिप में उनके वर्तमान स्थान से आदेश दिया गया है):

string[] teams = new string[] {"", "", "", "", "", "", "", "", "", "", "", "", " ", " ", "", ""}; 

2. जांचें कि क्या DrawTable [i, N] सेल भरा हुआ है। ऐसा करने के लिए, शुरू में सरणी के प्रत्येक तत्व को किसी भी नकारात्मक संख्या में असाइन करें, उदाहरण के लिए {-1}:

 drawtable[i, j]=-1; if (drawtable[i, j] < 0) {…} 

3. हम एन टीम के लिए यादृच्छिक प्रतिद्वंद्वियों को उत्पन्न करने की प्रक्रिया शुरू करते हैं: टेबलड्रॉव [i, N] = रैंडम = एमआई इनपुट स्थितियों को नियंत्रित करने और पूरा करने के लिए 3-5:

 int pair = generator.Next(1000, 1000000)%teams.Length; 

मूल रूप से उपयोग किया जाता है

 int pair = generator.Next(0, teams.Length) 

हालाँकि, इस व्याख्या में उत्पन्न संख्याओं का बिखराव अपर्याप्त है और उन्होंने एक सरणी बनाने की अनुमति नहीं दी है।
प्रारंभ में, स्थिति 3 की जाँच की जाती है:

 if (pair != j) 

आगे खड़ी है

 if (pair != drawtable[k, j]) 

और क्षैतिज जाँच

 if (pair != drawtable[i, k]) 

शर्तें 4।
यदि शर्तें 3, 4 पूरी हो जाती हैं, तो एक जोड़ी बनती है:

 drawtable[i, j] = pair; drawtable[i, pair] = j; 

प्रत्येक दौर में प्रत्येक प्रतिभागी के लिए उपरोक्त ऑपरेशन किए जाते हैं:

 for (int i = 0; i < teams.Length - 1; i++) { for (int j = 0; j < teams.Length; j++) { } } 

परिणामस्वरूप, एक प्रतियोगिता तालिका निम्नानुसार बनाई गई है:

यदि, गलत सरणी गठन के कारण, तथाकथित "मछली" (और यह उठता है) स्थिति उत्पन्न होती है, जब कोई समाधान नहीं होता है, तो पुनरावृत्तियों को वापस रोल करना होगा, बशर्ते कि सरणी जितनी बड़ी होगी, पुनरावृत्तियों की संख्या उतनी ही अधिक होगी। इस स्थिति में, अंतिम पुनरावृत्ति वापस ले ली गई है:

 fail++; if (fail > teams.Length) {for (int k = 0; k < teams.Length; k++){drawtable[i, k] = -1;} fail = 0; j = -1;} 

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