स्वचालित रूप से स्पोर्ट्स लीग शेड्यूल कैसे उत्पन्न करें

Question

मैं यह कहकर शुरू करूंगा कि मैं समझता हूं कि यह विषय जटिल है और संभवतः कोई आसान जवाब नहीं है। अगर यह आसान था तो सब लोग ऐसा करेंगे। कहा जा रहा है ...

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

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

विचार?

Answer 1

उदाहरण के लिए उपयोग की जाने वाली एक सुंदर सीधी प्रणाली है राउंड-रॉबिन नामक शतरंज टूर्नामेंट।

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

Wikipedia article।

आपके विशेष मामले में मैं सभी टीमों सहित एक बार राउंड रॉबिन करने का प्रयास करूंगा। फिर आप प्रत्येक विभाजन के लिए एक ही करते हैं और यह सुनिश्चित करने के लिए कि डिवीजनों के भीतर टीम एक बार घर पर एक बार खेलते हैं और एक बार दूर हो जाते हैं, पहले राउंड रॉबिन से जांचें कि टीमों ने उस दौर में किस तरह खेला था।

इस बात का निचला पक्ष यह है कि टूर्नामेंट खत्म होने से पहले आप सभी इंटर-डिवीजन मैचों को अच्छी तरह से खेलेंगे (क्योंकि अंतिम एन -1 मैचों इंट्रा-डिवीजन टीमों के खिलाफ हैं [एन = टीमों की संख्या विभाजन])। यदि यह एक समस्या है तो आप बस थोड़ा सा मैचों को स्वैप कर सकते हैं।

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

#!/usr/bin/python 

div1 = ["Lions", "Tigers", "Jaguars", "Cougars"] 
div2 = ["Whales", "Sharks", "Piranhas", "Alligators"] 
div3 = ["Cubs", "Kittens", "Puppies", "Calfs"] 

def create_schedule(list): 
    """ Create a schedule for the teams in the list and return it""" 
    s = [] 

    if len(list) % 2 == 1: list = list + ["BYE"] 

    for i in range(len(list)-1): 

     mid = int(len(list)/2) 
     l1 = list[:mid] 
     l2 = list[mid:] 
     l2.reverse()  

     # Switch sides after each round 
     if(i % 2 == 1): 
      s = s + [ zip(l1, l2) ] 
     else: 
      s = s + [ zip(l2, l1) ] 

     list.insert(1, list.pop()) 

    return s 


def main(): 
    for round in create_schedule(div1): 
     for match in round: 
      print match[0] + " - " + match[1] 
    print 
    for round in create_schedule(div2): 
     for match in round: 
      print match[0] + " - " + match[1] 
    print 
    for round in create_schedule(div3): 
     for match in round: 
      print match[0] + " - " + match[1] 
    print 
    for round in create_schedule(div1+div2+div3): 
     for match in round: 
      print match[0] + " - " + match[1] 
     print 

if __name__ == "__main__": 
    main() 

Answer 2

मैं सिर्फ एक बूलियन सूत्र के रूप में इन बाधाओं सांकेतिक शब्दों में बदलना और समाधान प्राप्त करने के लिए (उदाहरण के लिए सी ++, जावा के लिए SAT4J, और तुम भी लिख सकता है के लिए MiniSAT आप सरल solver के मालिक हैं) कुछ SAT-solver का प्रयोग करेंगे। इन हलकों के लिए इनपुट डीआईएमएसीएस द्वारा स्टैंडराइज किया गया है।

इसी तरह की समस्याओं के एसएटी-एन्कोडिंग के लिए "सामाजिक गोल्फर समस्या के लिए एक एसएटी एन्कोडिंग" और "टूर्नामेंट अनुसूची के लिए एक एसएटी आधारित शेड्यूलर" भी देखें।

Answer 3

यहाँ एक कार्यान्वयन

public interface ITeam 
{ 
    bool PlaysOn(DateTime date); 
    bool canPlay(ITeam); //returns true if a game between the teams is legal (played once/twice 
         //already, same different divisions and other applicable rules 
} 

IEnumerable<ITeam> teams = null; //replace with initialization 
IEnumerable<ITeams> reversed = team.Reverse(); 
IEnumerable<DateTIme> gameDays = null;//replace with initialization 
var count = teams.Count(); 

foreach(var date in gameDays) 
{ 
    for(int i = 0;i<count;i++) 
    { 
     var innerTeams = i % 2 == 0 ? teams : reversed; 
     var team = (from t in innerTeams 
        where !t.PlaysOn(date) 
        select t).First(); 
     var opp = (from t in teams 
       where !t.PlaysOn(date) && t.CanPlay(team) 
       select t).First(); 
     SetupGame(team,opp); 
    } 
} //lot of optimazation possible :) 

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

Answer 4

दो एल्गोरिदम हैं, अजीब टीमों में से एक, यहां तक ​​कि टीमों के लिए भी यह सुनिश्चित करने के लिए कि राउंड रॉबिन होता है।

यदि मैं कर सकता हूं तो मैं आपको एक ग्राफिक उत्पन्न करने जा रहा हूं।

टीमों

की विषम # एल्गोरिथ्म दक्षिणावर्त सभी टीमों को घुमाने के लिए है। अगर हम 5 टीमों था: इस बिंदु पर

1 2 --> 3 1 --> 5 3 --> 4 5 --> 2 4 
3 4  5 2  4 1  2 3  1 5 
5  4  2  1  3 

हम एक राउंड रोबिन जहां हर कोई एक बार एक दूसरे को निभाता है ... अगले दौर फिर से होगा ..

1 2 
3 4 
5 

भी # के पूरा कर लिया है टीमें

जब हमारे पास टीमों की संख्या भी होती है, तो आप एक ही रोटेशन करते हैं, सिवाय इसके कि आप निश्चित स्थिति में टीम # 1 रखते हैं और अन्य सभी टीमों को घड़ी के रूप में # 1 के आसपास घूमते हैं। तो, अगर हम था 4 टीमों ..

1 2 --> 1 3 --> 1 4 
3 4  4 2  2 3 

यह एक पूरा राउंड रोबिन ... अगले मैच तक हो जाएगा ..

1 2 
3 4 

प्रोग्राम कुछ तरीके हैं जिन्हें आप दृष्टिकोण सकता है इस। हो सकता है कि ऊपर पोस्ट किया गया कोड वही काम करता है ..