È tempo ... di contare i voti!

Oggi ci sono elezioni locali in tutto il mio paese. Qui, il numero di posti per ciascuna parte viene deciso usando il metodo D'Hondt . Il tuo obiettivo è quello di implementare un programma o una funzione che deciderà quanti posti ogni parte ottiene, nel minor numero di byte.

Per questo metodo ci sono un numero fisso di posti da distribuire, ed è fatto così:

1. A ogni parte viene assegnato un numero variabile, che inizia con il numero di voti ottenuti.
2. Quindi il primo seggio viene assegnato alla parte che ha il valore più grande nella sua variabile e quindi quel valore per quella parte diventa il loro numero totale di voti diviso 1+seats, arrotondato per difetto, dove si seatstrova il numero di seggi che ha già (quindi dopo aver ottenuto il in primo luogo, i loro voti sono divisi per 2 e per 3 dopo aver ottenuto il secondo seggio).
3. Successivamente i voti delle parti vengono nuovamente confrontati. Il processo continua fino a quando tutti i posti non sono stati assegnati.

Se il numero più alto è un pareggio tra due o più parti, viene risolto in modo casuale (deve essere casuale, non può essere solo il primo dei due nell'elenco).

Ingresso

Riceverai un numero N, che indicherà il numero di seggi disponibili e un elenco dei voti ricevuti da ciascuna parte, in qualunque formato tu preferisca. Esempio:

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

Produzione

Dovresti fornire un elenco dei posti assegnati a ciascuna parte. Nell'esempio sopra sarebbe qualcosa di simile

8,5,9,2,1,0

Dovrebbero essere nello stesso ordine delle parti nell'input.

Esempi

5
3,6,1

outputs: 2,3,0

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

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

indennità

-20% di bonus se prendi il nome delle parti come input e forniscile nell'output, come ad esempio:

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

CJam, 35,2 28,8 28,0 26,4

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

Questo programma completo è lungo 33 byte e si qualifica per il bonus.

Provalo online nell'interprete CJam .

Esempio di esecuzione

$ 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]

Come funziona

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#

Pyth, 36 byte - 20% = 28,8

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

Questo si qualifica per il bonus.

Provalo online: cablaggio dimostrativo o di prova

Spiegazione:

                                       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

Javascript, 210 byte

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}

Appunti:

• Richiede un browser / motore moderno con supporto per ES6. Testato su Firefox.
• Utilizza l' /-~++operatore molto importante :)

Esempio di utilizzo:

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

Pyth - 54 byte

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

Formato di input (stdin):

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

Formato di output (stdout):

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

Variabili utilizzate:

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

Perl, 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"

Spazio di input separato dall'ultimo conteggio dei posti.

Prova a me .