वोटों की गिनती करने का समय आ गया है!

आज मेरे पूरे देश में स्थानीय चुनाव हैं। यहाँ, D'Hondt पद्धति का उपयोग करके प्रत्येक पार्टी के लिए सीटों की संख्या तय की गई है । आपका लक्ष्य एक प्रोग्राम या फ़ंक्शन को लागू करना है जो यह तय करेगा कि प्रत्येक पार्टी को कितनी सीटें मिलें, कम से कम बाइट्स में।

इस पद्धति के लिए सीटों की एक निश्चित संख्या को वितरित करना है, और यह ऐसा किया जाता है:

हर पार्टी को एक चर संख्या दी जाती है, जो उसे मिले वोटों की संख्या से शुरू होती है।
फिर पहली सीट उस पार्टी को दी जाती है, जिसके चर में सबसे बड़ा मूल्य होता है और फिर उस पार्टी के लिए उसका मूल्य उनके कुल वोटों की संख्या से विभाजित हो जाता है 1+seats, गोल हो जाता है, जहां seatsपहले से ही सीटों की संख्या है (इसलिए प्राप्त करने के बाद) पहले, उनके वोटों को 2 से विभाजित किया जाता है, और दूसरी सीट पाने के बाद 3 से)।
उसके बाद पार्टियों के वोटों की फिर से तुलना की जाती है। सभी सीटों को सौंपे जाने तक यह प्रक्रिया जारी है।

यदि उच्चतम संख्या दो या अधिक दलों के बीच एक टाई है, तो इसे यादृच्छिक रूप से हल किया जाता है (यह यादृच्छिक होना है, यह सूची में दो में से पहला नहीं हो सकता है)।

इनपुट

आपको एक संख्या प्राप्त होगी N, जो उपलब्ध सीटों की संख्या और प्रत्येक पार्टी को प्राप्त वोटों की एक सूची को इंगित करेगी, जो भी आप पसंद करते हैं। उदाहरण:

25
12984,7716,13009,4045,1741,1013

उत्पादन

आपको प्रत्येक पार्टी को मिली सीटों की सूची का उत्पादन करना चाहिए। ऊपर के उदाहरण में यह कुछ इस तरह होगा

8,5,9,2,1,0

उन्हें इनपुट में पार्टियों के समान क्रम में होना चाहिए।

उदाहरण

5
3,6,1

outputs: 2,3,0

135
1116259,498124,524707,471681,359705,275007,126435

outputs: 45,20,21,19,14,11,5

बक्शीश

-20% बोनस अगर पार्टियों का नाम इनपुट के रूप में लेते हैं और उन्हें आउटपुट में देते हैं, उदाहरण के लिए:

25
cio:12984,pcc:7716,irc:13009,icb:4045,cub:1741,bb:1013

outputs

cio:8
pcc:5
irc:9
icb:2
cub:1
bb:0

code-golf

— rorlork
स्रोत

मुझे लगता है कि हमने पहले से ही कुछ ऐसा किया था

— edc65

मुझे खोज में कुछ भी समान नहीं मिला ... लेकिन अगर आपको कुछ मिला तो मैं इसे बदल दूंगा या प्रश्न को हटा दूंगा, कोई बात नहीं!

— रॉलकॉर

@ आर्कम अपने अंतिम उदाहरण में कुछ गड़बड़ है। शायद आपका मतलब 135 की बजाय 153 कुल सीटों का था।

— टाइलो

@ टाइटिलो राइट! मैंने अपने परीक्षण कार्यक्रम में इसे गलत लिखा और दोहरे-जाँच के बिना उत्तरों की नकल की। यह अब तय हो गया है। धन्यवाद!

— रॉलर्क

1

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

— रॉलर्क

6

सीजेम, 35.2 28.8 28.0 26.4

q2*~,m*mr{~)f/1=~}$<:(f{1$e=1\tp}

यह पूरा कार्यक्रम 33 बाइट लंबा है और बोनस के लिए योग्य है।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

उदाहरण चलाते हैं

$ cjam seats <<< '[["cio"12984]["pcc"7716]["irc"13009]["icb"4045]["cub"1741]["bb"1013]]25'
["cio" 8]
["pcc" 5]
["irc" 9]
["icb" 2]
["cub" 1]
["bb" 0]

यह काम किस प्रकार करता है

q2*~   e# Repeat the input from STDIN twice. Evaluate.
       e# STACK: Array seats Array seats
,      e# Range: seats -> [0 ... seats-1]
m*     e# Take the cartesian product of the array from the input and the range.
mr     e# Shuffle the array. This makes sure tie breakers are randomized.
{      e# Sort by the following key:
  ~    e#     Dump: [["party" votes] number] -> ["party" votes] number
  f/   e#     Divide each: ["party" votes] number -> ["party"/number votes/number]
  1=   e#     Select: ["party"/number votes/number] -> votes/number
  ~    e#     Bitwise NOT.
}$     e#
<      e# Keep only the elements that correspond to seats.
:(     e# Shift each array.
       e# RESULT: S := [[number] ["party" votes] [number] ["party" votes] ...]
f{     e# For each A := ["party" votes]:
       e#     Push S.
  1$   e#     Push a copy of A.
  e=   e#     Count the occurrences of A in S.
  1\t  e#     Replace the vote count with the number of occurrences.
  p    e#     Print.
}      e#

— डेनिस
स्रोत

6

पायथ, 36 बाइट्स - 20% = 28.8

J<_hCo/@eCQhNheN.S*UQUvzvz.e,b/JkhCQ

यह बोनस के लिए योग्य है।

इसे ऑनलाइन आज़माएं: प्रदर्शन या टेस्ट हार्नेस

स्पष्टीकरण:

                                       implicit: z = 1st input (as string)
                                                 Q = 2nd input (evaluated)

                      vz               evaluate z (#seats)
                     U                 generate the list [0,1,...,seats-1]
                   UQ                  generate the list [0,1,...,len(Q)-1]
                  *                    Cartesian product of these lists
                .S                     shuffle (necessary for break ties randomly)
     o                                 order these tuples N by:
        eCQ                               list of votes
       @   hN                             take the N[0]th vote count
      /      heN                          and divide by N[1]+1
   hC                                  extract the party index of the tuples
  _                                    reverse the list
 <                      vz             take the first #seats elements
J                                      and store them in J

                          .e     hCQ   enumerated map over the names of the parties
                                       (k = index, b = name):
                            ,             generate the pair:
                             b/Jk            name, J.count(k)
                                       print implicitely

— Jakube
स्रोत

Jअनावश्यक है। आप इससे छुटकारा पा सकते हैं और 2 बाइट्स बचा सकते हैं।

— इसहाक

इसके अलावा, अगर आप स्वैप करते हैं zऔर Qफिर सेव Cvzकरते हैं K, तो आप एक और बाइट बचा सकते हैं।

— इसहाक

@ आइसाकग नोप, यह बहुत महत्वपूर्ण है। क्योंकि फेरबदल की अभिव्यक्ति में अलग परिणाम मिल सकता है .eऔर यह गिनती गड़बड़ कर देता है।

— जकुबे

1

वास्तव में, दूसरा टिप या तो काम नहीं करता है, क्षमा करें, क्योंकि मैं चूक गया था UQ।

— इसहाक

2

@isaacg इसे उत्तर के रूप में पोस्ट करें।

— जकुबे

5

जावास्क्रिप्ट, 210 बाइट्स

v=(a,b,c,d,e,f,g)=>{d=Object.assign({},b),c={};for(g in b)c[g]=0;for(;a--;)e=0,f=Object.keys(d),f.forEach(a=>e=d[a]>e?d[a]:e),f=f.filter(a=>d[a]===e),f=f[~~(Math.random()*f.length)],d[f]=b[f]/-~++c[f];return c}

टिप्पणियाँ:

ES6 के लिए समर्थन के साथ एक आधुनिक ब्राउज़र / इंजन की आवश्यकता होती है। फ़ायरफ़ॉक्स में परीक्षण किया गया।
बहुत महत्वपूर्ण /-~++ऑपरेटर का उपयोग करता है :)

उदाहरण का उपयोग:

v(25, {cio:12984,pcc:7716,irc:13009,icb:4045,cub:1741,bb:1013})

— user2951302
स्रोत

1

अपने सभी चर को तर्क के रूप में घोषित करना आवश्यक नहीं है।

— अंडरस्कोर'

2

हां, लेकिन मैं संभव के वैश्विक दायरे को प्रदूषित करने से बचना चाहता था

— user2951302

1

जेएस गोल्फ

— गोबल

2

मैंने आपकी विधि को 168 बाइट्स तक नीचे कर दिया है। चर नामों को प्रबंधित करने के लिए क्षमा करें।

F=(N,X)=>{for(t=[o={}],[t[o[j]=0,j]=X[j]for(j in X)];N--;t[z=y[new Date%y.length]]=X[z]/-~++o[z])m=0,y=[(m=m<t[j]?t[j]:m,j)for(j in X)],y=y.filter(j=>t[j]==m);return o}

— 15:15

4

पायथ - 54 बाइट्स

AGZQ=kZK*]0lZVGJhOfqeTh.MZZ.e(kb)Z XJK1 XZJ/@kJ+@KJ1;K

इनपुट प्रारूप (स्टडिन):

[25,[12984,7716,13009,4045,1741,1013]]

आउटपुट प्रारूप (स्टडआउट):

[8, 5, 9, 2, 1, 0]

प्रयुक्त चर:

G = total number of seats
K = array of seats currently assigned to each party
k = number of votes for each party
Z = k/(K+1)
J = which party should have the next seat

— Tyilo
स्रोत

का प्रयोग करें vzऔर Qके बजाय Gऔर Z। इस तरह से आप असाइनमेंट को सेव कर लेंगे A।

— जेक्यूब

2

पर्ल, 110

#!perl -pa
$n=pop@F;@x=map
0,@F;/a/,$x[$'/$n]++for(sort{$b-$a}map{map{($'/$_|0).rand.a.$i++}//..$n}@F)[0..$n-1];$_="@x"

सीट की गिनती के साथ इनपुट स्पेस अलग हो गया।

मुझे आजमाओ ।

— nutki
स्रोत

चुनाव का समय है!

वोटों की गिनती करने का समय आ गया है!

इनपुट

उत्पादन

उदाहरण

बक्शीश

सीजेम, 35.2 28.8 28.0 26.4

उदाहरण चलाते हैं

यह काम किस प्रकार करता है

पायथ, 36 बाइट्स - 20% = 28.8

स्पष्टीकरण:

जावास्क्रिप्ट, 210 बाइट्स

पायथ - 54 बाइट्स

पर्ल, 110