परिचय
एक आम चुनाव में, एक प्रति संसद सीट की लगातार कीमत की गणना करना चाहेगा। इसका मतलब यह है कि N >= 0सीटों के वितरण के लिए और nsप्रति पार्टी वोटों की एक सूची के लिए , हम एक dऐसी संख्या खोजना चाहेंगे
sum(floor(n/d) for n in ns) == N
चीजों को दिलचस्प बनाने के लिए (और वास्तविक दुनिया की तरह), हम दो और तथ्य जोड़ते हैं:
दो दल एक parties गठबंधन ’में एकत्रित हो सकते हैं, जिससे कि सभी दलों को वोटों के योग से a गठबंधन’ को सीटें मिलें। फिर जिन सीटों पर 'गठबंधन' हुआ, वे कुछ इसी अंदाज में पार्टियों में बंट गईं (विभाजक खोजें, आदि)।
एक पार्टी जो वोटों का एक निश्चित प्रतिशत पारित नहीं करती (उदाहरण के लिए 3.25%) को स्वचालित रूप से 0 सीटें मिलती हैं, और उसके वोटों की गिनती 'गठबंधन' के लिए नहीं होती है।
चुनौती
तुम्हे दिया गया है :
- सूचियों की एक सूची, प्रत्येक नेस्टेड सूचियों में पूर्णांक (वोटों की संख्या) होती है, और किसी एक पार्टी के लिए लंबाई 1 या 'गठबंधन' के लिए लंबाई 2 होती है।
- सीटों को पाने के लिए न्यूनतम प्रतिशत वोट (उर्फ "बार" "बैराज"), एक अंश के रूप में (इसलिए 3.25% 0.0325 के रूप में दिया जाता है)
- सभी दलों के बीच वितरित की जाने वाली सीटों की कुल संख्या (पूर्णांक)
आपको समान नेस्टेड सूची संरचना का प्रिंट आउट लेना है, संसद की सीटों के साथ वोट की संख्या के साथ।
विजेता बाइट्स की सबसे छोटी राशि वाला कोड है।
कोने के मामले:
- एक से अधिक संभावित भाजक हो सकते हैं (और आमतौर पर होंगे)। चूंकि यह आउटपुट में नहीं है, इसलिए यह वास्तव में मायने नहीं रखता।
- कल्पना करें
N=10औरns = [[1]], इसलिए विभाजक 0.1 हो सकता है (पूर्णांक नहीं) - कुछ मामलों उदाहरण के लिए हल नहीं किया जा सकता है, ,
ns=[[30],[30],[100]], ।bar=0N=20एक सीमा होती हैd=7.5जहाँ 19 से 21 तक फ़्लार किए गए मानों का योग कूदता है। आपको इन मामलों को हल करने की उम्मीद नहीं है। (इस मामले को इंगित करने के लिए समुदाय के सदस्य अरनुलद को धन्यवाद)
उदाहरण इनपुट और आउटपुट
एक बहुत ही नहीं अनुकूलित पायथन 3 उदाहरण:
from math import floor
def main(_l, bar, N):
# sum all votes to calculate bar in votes
votes = sum(sum(_) for _ in _l)
# nullify all parties that didn't pass the bar
_l = [[__ if __ >= bar * votes else 0 for __ in _] for _ in _l]
# find divisor for all parliament seats
divisor = find_divisor([sum(_) for _ in _l], N)
# find divisor for each 'coalition'
divisors = [find_divisor(_, floor(sum(_)/divisor)) for _ in _l]
# return final results
return [[floor(___/_) for ___ in __] for _, __ in zip(divisors, _l)]
def find_divisor(_l, N, _min=0, _max=1):
s = sum(floor(_ / _max) for _ in _l)
if s == N:
return _max
elif s < N:
return find_divisor(_l, N, _min, (_max + _min) / 2)
else:
return find_divisor(_l, N, _max, _max * 2)
print(main(l, bar, N))उदाहरण इनपुट:
l = [[190970, 156473],
[138598, 173004],
[143666, 193442],
[1140370, 159468],
[258275, 249049],
[624, 819],
[1125881],
[152756],
[118031],
[74701]]
bar = 0.0325
N = 120और इसका आउटपुट:
[[6, 4], [0, 5], [4, 6], [35, 5], [8, 8], [0, 0], [35], [4], [0], [0]]कुछ और उदाहरण आउटपुट:
यदि bar=0.1हम दो दलों के बीच एक दिलचस्प गतिरोध प्राप्त करते हैं, क्योंकि छोटे दलों में से किसी की गिनती नहीं की जाती है:
[[0, 0], [0, 0], [0, 0], [60, 0], [0, 0], [0, 0], [60], [0], [0], [0]]और अगर N=0(कोने का मामला) तो निश्चित रूप से किसी को कुछ नहीं मिलता है:
[[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0], [0], [0], [0]]d=7.5आपको 19 सीटों से 21 सीटों तक की छलांग मिलती है।