How to find all integer combinations with a max "order"

The question is as follows:

Considering a set: [k0, k1, ......, kn] and all the elements are integers. The "order" is defined as |k0| + |k1| + ... + |kn|. Assuming max order m_max, how can I find every combination of k0, ..., kn that has an order less than the max order m_max?

My own attempt is as follows:

It's easy to find that the max range of each ki is from -m to m, so I can just go through this range for every ki and check every possible combination. Then this problem becomes a simple problem that transform an (2m + 1)-nary number to decimal.

For example: n = 1, m = 2. It's easy to list every possible combinations without considering the order criteria:

1. (-2, -2, -2) order = 6 -------(x) -> (0,0,0) -> "5-nary" 000
2. (-1, -2, -2) order = 5 -------(x) -> (1,0,0) -> "5-nary" 001
3. (0, -2, -2) order = 4 -------(x) -> (2,0,0) -> "5-nary" 002
4. (1, -2, -2) order = 5 -------(x) -> (3,0,0) -> "5-nary" 003
5. (2, -2, -2) order = 6 -------(x) -> (4,0,0) -> 004
6. (-2,-1,-2) order = 5 -------(x) -> (0,1,0) -> 010
7. (-1,-1,-2) order = 4 -------(x) -> (1,1,0) -> 011

......

125. (2,2,2) order = 6 ----------(x)

I can do this traversal using a decimal range (0, 125). Every test combination is a transformation from the decimal to 5-nary number.
However, I found this method quite computational intensive.

In short, I need all possible combinations that have a sum of absolute values limited by m.

How to generate all combinations with :

• n elements
• limit m per absolute value of element
• limit order for sum of absolute values of elements

At first generate all distinct ordered partitions of numbers 0.. order into n summands like this:

n=4, m=2, order = 4
o=0: [0,0,0,0]
o=1: [0,0,0,1]
o=2  [0,0,0,2], [0,0,1,1] 
o=3  [0,0,0,3], [0,0,1,2], [0,1,1,1]  
o=4  [0,0,0,4], [0,0,1,3], [0,1,1,2],[0,0,2,2]  

Edit: It is worth to change order of stages to avoid duplicates problems:

For every parition generate permutations (don't forget about repeats, next_permutation algorithm does treat them properly).

[0, 1, 1, 2] =>  [0, 1, 1, 2], [0, 1, 2, 1], [0, 2, 1, 1], 
                 [1,0,1,2], [1,0,2,1], [1,1,0,2], [1,1,2,0], [1,2,0,1], [1,2,1,0],
                 [2, 0, 1, 1], [2, 1, 0, 1], [2, 1, 1, 0]

Then for every permutation containing k non-zero elements, make 2^k final combination results with distinct signs

[0,1,2,1] => [0,1,2,1],[0,1,2,-1],[0,1,-2,1],[0,1,-2,-1],
             [0,-1,2,1],[0,-1,2,-1],[0,-1,-2,1],[0,-1,-2,-1]

Thanks to MBo for clarifying the question...

What you're asking to do can generate a lot of output, so I'm doubtful that it's the best way to accomplish whatever your larger purpose is.

I know a fun way to do it, though. Here's an implementation with comments in python:

def print_combos(N,m,order):
    remaining = order
    elements=[]
    while True:
        # Fill remainder of the array with lexically least
        # valid sequence
        while len(elements) < N:
            # note this is negative or 0
            nextval = max(-remaining, -m)
            elements.append(nextval)
            remaining += nextval
        
        print(elements)
        
        # find the right-most element that we can increment
        while len(elements) > 0:
            val = elements.pop()
            remaining += abs(val)
            if val < 0 or (val < m and remaining > val):
                elements.append(val+1)
                remaining -= abs(val+1)
                break
        
        if len(elements) < 1:
            # all done
            break

print_combos(3, 3, 6)