Compte tenu de la liste des populations de chaque État, affichez, du plus grand au moins, le nombre de votes que cet État obtient au collège électoral.

Entrée: le premier chiffre représente le nombre total de votes à distribuer; il est suivi d'une liste de et de populations. Dans cet exemple, les abréviations des états sont utilisées, mais tout nom contenant des lettres majuscules et minuscules peut être utilisé. Vous pouvez le prendre dans le format de votre choix, tant que la seule information contenue est l'abréviation de l'État et sa population.

L'entrée peut être considérée comme un argument pour une fonction, ou comme vous le souhaitez.

Exemple d'entrée (possible): 538 [[CA 38000000], [NH 1300000] etc.]

Sortie: affiche, dans un certain format, le nombre de votes que chaque État obtient. Ordonnez les États du plus grand au moins. Si deux États ont le même nombre de votes, l'ordre par n'importe quel nom apparaîtra en premier dans un dictionnaire (qui apparaît en premier par ordre alphabétique).

Avant de trouver le nombre de votes, vérifiez d'abord s'il y a un état nommé DC dans la liste des entrées, et s'il y en a, donnez à l'État 3 votes, quelle que soit sa population. Ensuite, supprimez-le de la liste et attribuez le reste des votes comme si DC n'existait pas.

Le nombre de voix au collège électoral est défini comme la somme du nombre de sénateurs et de représentants. Chaque État a deux sénateurs, alors soustrayez le double du nombre d'États (538, dans l'exemple d'entrée) pour obtenir le nombre de représentants. Attribuez à chaque État un représentant pour commencer. Ensuite, effectuez le processus suivant:

1. Attribuez à chaque état un nombre, Adéfini comme étant P/sqrt(2)où se Ptrouve la population.

2. Trier les états en fonction de leurs valeurs de A.

3. Attribuez le premier état (celui avec le plus grand A) un représentant de plus.

4. Réaffectez les valeurs de A, as A = P/(sqrt(n)*sqrt(n + 1)), où nest le nombre actuel de représentants affectés à l'État.

5. Revenez à l'étape 2. Répétez jusqu'à ce que tous les représentants soient épuisés.

Exemple (possible) sortie: {CA: 518, NH: 20}. La sortie ne doit pas nécessairement être dans ce format, mais doit contenir les mêmes informations.

Notez que s'il n'est pas possible d'attribuer des votes légalement parce qu'il y a moins de 3*(# of states)votes, imprimez ce que vous voulez. Vous pouvez planter, lancer une erreur, etc.

Cas de test:

538 [['CA' 38000000], ['NH' 1300000]] --> CA: 518, NH: 20
538 [['NH' 1300000], ['CA' 38000000]] --> CA: 518, NH: 20 (must be in order from greatest to least!)
538 [['DC' 1000000], ['RH' 1]] --> RH: 535, DC: 3
100 [['A', 12], ['B', 8], ['C', 3]] --> A: 51, B: 35, C: 14
100 [['A', 12], ['B', 8], ['C', 3], ['D', 0]]: --> [49, 34, 14, 3] (yes, even states with no population get votes)
2 [['A', 1]] --> aasdfksjd;gjhkasldfj2fkdhgas (possible output)
12 [['A', 1], ['B', 2], ['C', 3], ['D', 4]] --> A: 3, B: 3, C: 3, D: 3
42 [['K', 123], ['L', 456], ['M', 789]] --> M: 23, L: 14, K: 5
420 [['K', 123], ['L', 456], ['M', 789]] --> M: 241, L: 140, K: 39
135 [['C', 236841], ['D', 55540], ['G', 70835], ['K', 68705], ['M', 278514], ['Ms', 475327], ['Nh', 141822], ['Nj', 179570], ['Ny', 331589], ['Nc', 353523], ['P', 432879], ['R', 68446], ['Sc', 206236], ['Ve', 85533], ['Vi', 630560]] --> Vi: 20, Ms: 16, P: 14, Nc: 12, Ny: 12, M: 10, C: 9, Sc: 8, Nj: 7, Nh: 6, Ve: 5, D: 4, G: 4, K: 4, R: 4

Propre , 263 244 222 octets

v n s=sortBy(\(a,b)(c,d).b>d)([(t,3.0)\\t<-s|fst t=="DC"]++w(n-3*(length s))[(t,1.0)\\t<-s|fst t<>"DC"])
w 0s=w 0 s=[(p,r+2.0)\\(p,r)<-s]
w n s#s=sortBy(\a b.A a>A b)s
#(p,r)=hd s
=w(n-1)[(p,r+1.0):tl s]
A((_,p),r)=p/sqrt(r*r+r)

Appelez comme

Start = v 538 [("DC", 1000000.0), ("RH", 1.0)]

Version non golfée, programme complet ( census.icl):

module census

import StdEnv

Start = votes 538 [("DC", 1000000.0), ("RH", 1.0)]

votes n states
# dc = filter (((==)"DC")o fst) states
= sortBy (\(a,b)(c,d).b>d) ([(t,3.0) \\ t <- dc] ++ votes` (n-3*length states) [(t,1.0)\\t<-removeMembers states dc])
where
    votes` 0 states = map (\(p,r).(p,r+2.0)) states
    votes` n states
    # states = sortBy (\a b.A a > A b) states
    # (p,r) = hd states
    = votes` (n-1) [(p,r+1.0):tl states]

    A ((_,p),r) = p / sqrt(r*r+r)

JavaScript ES6, 249 octets 244 octets

(r,s)=>{r-=s.length*3;s=s.map(t=>({s:t[0],p:t[1],a:t[1]/(q=Math.sqrt)(2),r:1}));while(r--)(t=>t.a=t.p/q(++t.r)/q(t.r+1))(s.filter(t=>t.s!='DC').sort((a,b)=>b.a-a.a)[0]);return''+s.sort((a,b)=>(r=b.r-a.r)?r:a.s>b.s?1:-1).map(t=>t.s+':'+(t.r+2))}

Cas de test

d = (r, s) => {
  r -= s.length * 3;
  s = s.map(t => ({
    s: t[0],
    p: t[1],
    a: t[1] / (q = Math.sqrt)(2),
    r: 1
  }));
  while (r--)(t => t.a = t.p / q(++t.r) / q(t.r + 1))(s.filter(t => t.s != 'DC').sort((a, b) => b.a - a.a)[0]);
  return '' + s.sort((a, b) => (r = b.r - a.r) ? r : a.s > b.s ? 1 : -1).map(t => t.s + ':' + (t.r + 2))
};

document.write(
  '<pre>' +
  d(135, [
    ['C', 236841],
    ['D', 55540],
    ['G', 70835],
    ['K', 68705],
    ['M', 278514],
    ['Ms', 475327],
    ['Nh', 141822],
    ['Nj', 179570],
    ['Ny', 331589],
    ['Nc', 353523],
    ['P', 432879],
    ['R', 68446],
    ['Sc', 206236],
    ['Ve', 85533],
    ['Vi', 630560]
  ]) +
  '</pre>'
);

Merci à @Neil pour avoir économisé 5 octets!

Python 2, 219 octets

v,s=input()
n={k:1 for k in s}
v-=3*len(s)
l=lambda x:-x[1]
if'DC'in s:del s['DC']
while v:A,_=sorted([(a,s[a]/(n[a]**2+n[a])**.5)for a in s],key=l)[0];n[A]+=1;v-=1
for a in n:n[a]+=2
print sorted(list(n.items()),key=l)

Prend l'entrée comme

420,{'K':123,'L':456,'M':789}

Tirages:

[('M', 241), ('L', 140), ('K', 39)]