Find good coalitions
As you might know, there were elections in Germany, and now the parties have to form a government coalition. Let's help them with it!
A good coalition has the strict majority of seats (that is, more seats than the opposition). Moreover you don't want more parties than necessary in a coalition, that is, if you still have a majority after removing one of the parties, it's not a good coalition.
You are given a list of parties and their number of seats. Your task is to output a list of good coalitions, where each coalition is given by a list of its members. For this task, a coalition may also consist of a single party.
Input and output may be in any suitable form (e.g. they need not be lists, but can be sets, dictionaries, XML, …). Note that the order of the parties in each coalition does not matter, nor does the order of coalitions. For example, the output [["nano", "vi"], ["nano", Emacs"], ["vi", "Emacs"]]
is equivalent to [["vi", Emacs"], ["Emacs", "nano"], ["nano", "vi"]]
.
This is code-golf, the shortest code wins.
Test cases:
{"nano": 25}
→ [["nano"]]
{"vi": 20, "Emacs": 21}
→ [["Emacs"]]
{"vi": 20, "Emacs": 20}
→ [["vi", "Emacs"]]
{"nano": 20, "vi": 15, "Emacs": 12}
→ [["nano", "vi"], ["nano", Emacs"], ["vi", "Emacs"]]
{"nano": 25, "vi": 14, "Emacs": 8, "gedit": 6}
→ [["nano", "vi"], ["nano", "Emacs"], ["nano", "gedit"], ["vi", "Emacs", "gedit"]]
{"nano": 16, "vi": 14, "Emacs": 8, "gedit": 6}
→ [["nano", "vi"], ["nano", "Emacs"], ["vi", "Emacs", "gedit"]]
{"nano": 10, "vi": 10, "Emacs": 5, "gedit": 5}
→ [["nano", "vi"], ["nano", "Emacs", "gedit"], ["vi", "Emacs", "gedit]]
2 answers
Haskell, 141 bytes
import Control.Monad
f a=map(map fst)$filter(\c->let{g=map
snd;e=sum(g a)`div`2;f=g c;d=sum
f}in d>e&&all((<=e).(d-))f)$filterM(pure[1<0..])a
Explanation: we generate all possible coalitions and then filter out the bad ones. filterM(pure[1<0..])a
is the powerset of input.
0 comment threads
The following users marked this post as Works for me:
User | Comment | Date |
---|---|---|
General Sebast1an | (no comment) | Oct 5, 2021 at 10:52 |
Python 3, 191 bytes
lambda p:[c for c in chain(*[C(p,r)for r in range(len(p)+1)])if all(all(i==(sum(p.values())/2>=sum(p[n]for n in d))for d in C(c,len(c)-i))for i in[0,1])]
from itertools import*;C=combinations
Yay for quadruple nested list compressions...
Explanation
First we take the powerset:
lambda p:[c for c in chain(*[C(p,r)for r in range(len(p)+1)])
Then we filter.
if all(all(i==(sum(p.values())/2>=sum(p[n]for n in d))for d in C(c,len(c)-i))
for i in[0,1])]
from itertools import*;C=combinations # Imports and aliases
There's a neat little trick: we want to have the set sum greater than s/2
(the average), while having the n-1
sized subsets' sums less than or equal to s/2
. By realizing that the full set is equal to the n
sized subset, we can combine both of them:
n subset > s/2 and n-1 subset <= s/2
is equivalent to
(n subset <= s/2) == 0 and (n-1 subset <= s/2) == 1
is equivalent to
(n-i subset <= s/2) == i) for i in [0,1]
0 comment threads