This kata is an extension of "Combinations in a Set Using Boxes":https://www.codewars.com/kata/5b5f7f7607a266914200007c

The goal for this kata is to get all the possible combinations (or distributions) (with no empty boxes) of a certain number of balls, but now, **with different amount of boxes.** In the previous kata, the number of boxes was always the same

Just to figure the goal for this kata, we can see in the picture below the combinations for four balls using the diagram of Hasse:



Points that are isolated represent balls that are unique in a box.
k points that are bonded in an area respresent a subset that is content in a box.

The unique square at the bottom of the diagram, means that there is only one possible combination for four balls in four boxes.

The above next line with 6 squares, means that we have 6 possible distributions of the four balls in 3 boxes. These six distributions have something in common, all of them have one box with 2 balls.

Going up one line more, we find the 7 possible distributions of the four balls in 2 boxes. As it is shown, we will have 7 distributions with: three balls in a box and only one ball in the another box, or two balls in each box.

Finally, we find again at the top, an unique square, that represents, the only possible distribution, having one box, the four balls together in the only available box.

So, for a set of 4 labeled balls, we have a total of 15 possible distributions (as always with no empty boxes) and with a maximum of 7 possible distributions for the case of two boxes.

Prepare a code that for a given number of balls (an integer), may output an array with required data in the following order:
```
[total_amount_distributions, maximum_amount_distributions_case_k_boxes, k_boxes]
```
Just see how it would be for the example given above:
```
combs_non_empty_boxesII(4) == [15, 7, 2] # A total of 15 combinations            
                                         #The case with maximum distributions is 7 using 2 boxes.

```
Features of the random tests:
```
1 < n <= 1800 (python)
1 < n <= 1200 (ruby)
```
You may see the example tests for more cases.
Enjoy it!
Ruby version will be published soon.

Source: codewars | Difficulty: EASY
Tags: Number theory

Combinatorics

Mathematics

Starter code: def combs_non_empty_boxesII(n):
	

Solutions:
MAX_BALL = 2 + 1800
(DP, lst) = ([None], [0, 1])
for _ in range(MAX_BALL):
	DP.append([sum(lst), *max(((v, i) for (i, v) in enumerate(lst)))])
	lst.append(0)
	lst = [v * i + lst[i - 1] for (i, v) in enumerate(lst)]
combs_non_empty_boxesII = DP.__getitem__


S = {}
for n in range(1, 1800):
	S[n, 1] = S[n, n] = 1
	for k in range(2, n):
		S[n, k] = S[n - 1, k - 1] + k * S[n - 1, k]

def combs_non_empty_boxesII(n):
	ss = [(S[n, k], k) for k in range(1, n + 1)]
	return [sum((p[0] for p in ss)), *max(ss)]


M = [[1] * 1800]
for V in range(2, 1801):
	U = [0]
	for (F, B) in enumerate(M[-1]):
		if F < 1799:
			U.append(0 if 1 + F < V else B + V * U[-1])
	M.append(U)

def combs_non_empty_boxesII(Q):
	R = [0, 0, 0]
	for V in range(Q):
		T = M[V][Q]
		R[0] += T
		if R[1] <= T:
			R[1:] = (T, 1 + V)
	return R


S = [[1]]
for n in range(1, 1801):
	S.append([1])
	for k in range(1, n):
		S[n].append(S[n - 1][k - 1] + (k + 1) * S[n - 1][k])
	S[n].append(1)

def combs_non_empty_boxesII(n):
	(tot, max, index) = (0, 1, 1)
	for ix in range(len(S[n - 1])):
		val = S[n - 1][ix]
		tot = tot + val
		if val >= max:
			max = val
			index = ix
	return [tot, max, index + 1]


sseq = [[1], [1, 1]]
s = [1, 1]
for t in range(2, 1800):
	s = [1] + [s[i - 1] + (i + 1) * s[i] for i in range(1, len(s))] + [1]
	sseq.append(s)

def combs_non_empty_boxesII(n):
	if n == 2:
		return [2, 1, 2]
	s = [1, 1]
	s = sseq[n - 1]
	return [sum(s), max(s), s.index(max(s)) + 1]