# 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 |
---|---|---|

Mark Giraffe | no | 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