पाइथन

Question

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

तो अगर वहाँ 4 प्रतिभागियों की एक टूर्नामेंट है:

[[1,4],[2,3]] 

7 प्रतिभागियों के टूर्नामेंट:

[[1,[4,5]],[[2,7],[3,6]]] 

या 8 प्रतिभागियों की एक टूर्नामेंट:

[[[1,8],[4,5]],[[2,7],[3,6]]] 

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

def decide_rounds(list_to_fill, player_nums): 
    if len(player_nums) < 3: 
     for num in player_nums: 
      list_to_fill.append(num) 
     return 

    left = [] 
    decide_rounds(left, ??????) #Tried passing various things to these with no avail. 
    list_to_fill.append(left) 
    right = [] 
    decide_rounds(right, ???????) 
    list_to_fill.append(right) 

इस पर कैसे पहुंचे इस पर कोई मदद या स्पष्टीकरण की सराहना की जाएगी!

संपादित करें: वर्तमान में मैं बोल रहा हूँ इस तरह समारोह:

rounds = [] 
decide_rounds(rounds, range(1, size +1)) 
print rounds 

Answer 1

इस प्रयास करें:

def divide(arr, depth, m): 
    if len(complements) <= depth: 
     complements.append(2 ** (depth + 2) + 1) 
    complement = complements[depth] 
    for i in range(2): 
     if complement - arr[i] <= m: 
      arr[i] = [arr[i], complement - arr[i]] 
      divide(arr[i], depth + 1, m) 

m = int(raw_input()) 

arr = [1, 2] 
complements = [] 

divide(arr, 0, m) 
print arr 

हम 2^n खिलाड़ियों के साथ एक ब्रैकेट के लिए, प्रत्येक जोड़ी का योग है कि नोटिस वही संख्या प्रत्येक जोड़ी के लिए, सही शब्द बाएं तत्व और पुनरावृत्ति की गहराई द्वारा निर्धारित किया जाता है, इसलिए हम केवल सरणी गहराई को उत्पन्न करके आगे बढ़ सकते हैं। हम रनटाइम को थोड़ा सा सुधारने के लिए पूरक को याद करते हैं। यह किसी भी m > 1 के लिए काम करता है क्योंकि पूरक बहुत बड़ा होने के बाद रिकर्सिंग बंद हो जाता है।

कार्य करते हुए देखें: http://ideone.com/26G1fB