I managed to find a solution through a
combination of recursion and loop.

Here's the pseudo code (I have no idea how to
write pseudo code...I'm denoting a list by [a; b;
c ...]:

```
// Returns a list of integers in range
[0, k].
function num_list k =
...
// Recursively generate all the possible
partitions with [total] objects
// and [groups] partitions. Returns a list of list
of integers.
function generate (int groups, int total) = {
if (groups == 1) then {
return [[total]];
} else {
int list nums = num_list total;
// looping through all values for one of
the partitions.
int list list list container1;
foreach (i in nums) {
// recursive step - generate all
combinations without the first
// partition
int list list subset = generate
(groups - 1) (total - i);
// append the first partition onto
each element of this list
int list list container2 = [];
foreach (l in subset) {
container2.add(l.prepend i);
}
container1.add container2;
}
// Flatten just takes a list of lists, and
extract everything in each
// list and mesh everything together.
return container1.flatten();
}
```

Here's the code in python:

```
# Recursively generate all the possible
partitions with [total] objects
# and [groups] partitions. Returns a list of list
of integers.
def generate (groups, total):
if (groups == 1):
return [[total]];
else:
nums = range(total + 1);
# looping through all values for one of
the partitions.
container1 = [];
for i in nums:
# recursive step - generate all
combinations without the first
# partition
subset = generate (groups - 1, total -
i);
# append the first partition onto each
element of this list
container2 = [];
for l in subset:
container2 += [([i] + l)];
container1 += [container2];
# Flatten just takes a list of lists, and
extract everything in each
# list and mesh everything together.
return [item for sublist in container1 for
item in sublist];
```

And here's the code in...functional programming
language ocaml:

```
(* Returns a list of integers in range
[0, k]. *)
let num_list n : int list =
let rec helper num =
if num = 0 then
[0]
else
num :: (helper (num - 1)) in
List.rev (helper n)
(**
* Recursively generate all the combinations when
dividing total number of
* objects among groups.
*)
let rec generate groups total : int list list =
(* generate all the possible *)
match groups, total with
| 1, t -> [[t]]
| g, t ->
let nums = num_list t in
(* looping through all values for the head
group *)
let helper e : int list list =
let subset = generate (g - 1) (t - e) in
(* appending in front of every single result
from generate *)
List.map (fun l -> e :: l) subset in
List.flatten (List.map helper nums)
```