Đã đến lúc ... để kiểm phiếu!

Hôm nay có cuộc bầu cử địa phương trong cả nước tôi. Tại đây, số lượng ghế cho mỗi bên được quyết định bằng phương pháp D'Hondt . Mục tiêu của bạn là triển khai một chương trình hoặc chức năng sẽ quyết định mỗi bên có bao nhiêu chỗ ngồi, với số lượng byte ngắn nhất.

Đối với phương pháp này, có một số lượng ghế cố định để phân phối, và nó được thực hiện như vậy:

1. Mỗi bên được chỉ định một số lượng khác nhau, bắt đầu từ số phiếu mà họ nhận được.
2. Sau đó, ghế đầu tiên được trao cho bên có giá trị lớn nhất trong biến của họ và sau đó giá trị đó cho bên đó trở thành tổng số phiếu được chia cho 1+seats, làm tròn xuống, seatssố ghế đã có (vì vậy sau khi nhận được đầu tiên, phiếu bầu của họ được chia cho 2 và 3 sau khi nhận được ghế thứ hai).
3. Sau đó, các bên bỏ phiếu được so sánh một lần nữa. Quá trình tiếp tục cho đến khi tất cả các ghế đã được chỉ định.

Nếu số cao nhất là một ràng buộc giữa hai hoặc nhiều bên, thì nó được giải quyết ngẫu nhiên (Nó phải là ngẫu nhiên, nó không thể là đầu tiên trong số hai bên trong danh sách).

Đầu vào

Bạn sẽ nhận được một số N, trong đó sẽ cho biết số lượng ghế có sẵn và danh sách số phiếu mà mỗi bên nhận được, theo bất kỳ định dạng nào bạn thích. Thí dụ:

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

Đầu ra

Bạn nên đưa ra một danh sách các ghế mà mỗi bên có. Trong ví dụ trên, nó sẽ giống như

8,5,9,2,1,0

Họ phải theo thứ tự như các bên trong đầu vào.

Ví dụ

5
3,6,1

outputs: 2,3,0

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

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

Tặng kem

-20% tiền thưởng nếu lấy tên của các bên làm đầu vào và cung cấp cho họ ở đầu ra, ví dụ như:

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}

Chương trình đầy đủ này dài 33 byte và đủ điều kiện nhận thưởng.

Hãy thử trực tuyến trong trình thông dịch CJam .

Chạy ví dụ

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

Làm thế nào nó hoạt động

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

Điều này đủ điều kiện cho tiền thưởng.

Dùng thử trực tuyến: Trình diễn hoặc thử nghiệm khai thác

Giải trình:

                                       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}

Ghi chú:

• Yêu cầu một trình duyệt / công cụ hiện đại có hỗ trợ ES6. Đã thử nghiệm trên Firefox.
• Sử dụng /-~++toán tử rất quan trọng :)

Ví dụ sử dụng:

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

Định dạng đầu vào (stdin):

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

Định dạng đầu ra (stdout):

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

Các biến được sử dụng:

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"

Không gian đầu vào được phân tách với số ghế cuối cùng.

Hãy thử tôi .