Combination N Choose K

A combination of $ k $ among $ n $ is the name given to the number of distinct ways of choosing $ k $ elements among a set of $ n $ distinct elements (with $ n \ge k $), without taking into account the order.

The combination is denoted by $ _nC^k $ or $ \binom{n}{k} $.

The generator allows selection of values $ k $ and $ n $, and generates possible lists of combinations with digits or letters (or a custom list).

The generation is intentionally limited to a few thousand combinations, because the number of results grows very rapidly with $ n $ and $ k $. This limit prevents any server overload.

To generate larger lists, dCode can generate them upon (paid) request.

The calculation uses the binomial coefficient: $$ C_n^k = \binom{n}{k} = \frac{n!}{k!(n-k)!} $$

Combinations uses calculus of factorials (the exclamation mark: !).

By principle, combinations do not take into account order (1,2) = (2,1). Use the function permutations to get possible ordered combinations.

dCode has a dedicated tool for combinations with repetitions.

To calculate the probabilities of winning in games of chance such as drawing random games, combinations are the most suitable tools.

To win at EuroMillions, a player ticks 5 boxes out of 50 (50 choose 5), then 2 stars out of 11 (11 choose 2).

To win at Powerball, pick 5 out of 69 (69 choose 5), then pick 1 out of 26 (26 choose 1).

To win at EuroDreams, the draw is 6 numbers from 40, then 1 number from 5.

Many books describes strategies for lotto or lottery such as here (affiliate link) One of the strategies is to play covering designs systems.

If $ k = 0 $, no element is selected. There is then only one possible combination: the empty set. By combinatorial convention, $$ \binom{n}{0} = 1 $$

If $ n = 0 $, then there is 0 item, impossible to pick $ k $, so there are no results. So $$ \binom{0}{k} = 0 $$

By convention 0 choose 0 is 1: $$ \binom{0}{0} = 1 $$

To count the combinations: // Python
def count_combinations(n, k):
if k > n - k:
k = n - k
result = 1
for i in range(1, k + 1):
result = result * (n - i + 1) // i
return result

To list the combinations: // Python
def combinations(n, k):
result = []
combo = list(range(k))
while True:
result.append(combo[:])
i = k - 1
while i >= 0 and combo[i] == n - k + i:
i -= 1
if i < 0:
break
combo[i] += 1
for j in range(i + 1, k):
combo[j] = combo[j - 1] + 1
return result// JavaScript
function combinations(a) { // a = new Array(1,2)
var fn = function(n, src, got, all) {
if (n == 0) {
if (got.length > 0) {
all[all.length] = got;
}
return;
}
for (var j = 0; j < src.length; j++) {
fn(n - 1, src.slice(j + 1), got.concat([src[j]]), all);
}
return;
}
var all = [];
for (var i=0; i < a.length; i++) {
fn(i, a, [], all);
}
all.push(a);
return all;
}