I wrote this while I was playing around with using q on a hobby project, and I thought I’d share it in case anyone else might find it useful.

It takes a number `k`

, a function `f`

, and a list or dictionary `y`

of count `n`

, and runs `f`

once for each of the *k*-combinations of `y`

. The result is returned as a dictionary with the function outputs as its values and its keys determined by the type of `y`

: if `y`

is a list, its keys are the subsets of `y`

that produced the outputs; if `y`

is a dictionary, its keys are the subsets of the keys of `y`

that index the subsets of `y`

that produced the outputs.

```
eachc:{
c:(where reverse 0b vs)each c@:where((first x)=sum 0b vs)each c:til"j"$2 xexp count y;
(last x)peach$[99h=type y;(key each y)!y:y{((key x)y)#x}/:c;y!y:y@/:c]}
```

Examples:

q)eachc[(3;sum)]til 5
0 1 2| 3
0 1 3| 4
0 2 3| 5
1 2 3| 6
0 1 4| 5
0 2 4| 6
1 2 4| 7
0 3 4| 7
1 3 4| 8
2 3 4| 9
q)eachc[(3;sum)]`a`b`c`d`e!til 5
a b c| 3
a b d| 4
a c d| 5
b c d| 6
a b e| 5
a c e| 6
b c e| 7
a d e| 7
b d e| 8
c d e| 9
q)

Notes and caveats:

On little-endian machines (i.e. Sparc), the `reverse`

will probably need to be removed.

The size of the result set gets very big very quickly—an `n`

of thirty is probably infeasible for most machines.

I’ve written it to execute `f`

on the combinations with `peach`

, rather than `each`

; this may or may not be appropriate, depending on the nature of any given `f`

and `y`

.