permutations and combinations of string - derivative

This is a derivative of permutations of a string. For digits [1, 2, 3], we want [1, 12, 21, 123, 132, 213, 231, 312, 321]. The permute_wrapper loops through the input array to permute the sub-array with limit marking its end.

def permute_wrapper(digits):
    input = [i for i in range(1, digits+1)]
    print(input)
    output = [0 for x in range(len(input))]
    flags = [False for x in range(len(input))]
    depth = 0
   
    for i in range(len(input)):
        permute_(input, i+1, output, flags, depth, nums)
   
    return nums

def permute_(input, limit, output, flags, depth, nums):
    if depth == limit:
        num = 0
        factor = 1
        for i in range(limit, 0, -1):
            num = num + output[i - 1] * factor
            factor *= 10
        nums.append(num)
        return None
   
    for i in range(limit):
        if flags[i] == True:
            continue
        flags[i] = True
        output[depth] = input[i]
       
        permute_(input, limit, output, flags, depth + 1, nums)
       
        flags[i] = False


For combinations of digits, instead of using a string buffer for output, an int array is used. index is used to keep track of where to insert the digit. The number is between index and 0 of output array.


def combine_wrapper(digits):
    input = [i for i in range(1, digits+1)]
    print(input)
    output = [0 for x in range(len(input))]
    start = 0
    index = 0
   
    combine_(input, output, start, index, nums)
   
    return nums

def combine_(input, output, start, index, nums):
    if start == len(input):
        return None
   
    for i in range(start, len(input), 1):
        output[index] = input[i]
       
        num = 0
        factor = 1
        for x in range(index, -1, -1):
            num = num + output[x] * factor
            factor *= 10
        nums.append(num)
       
        index+=1
        combine_(input, output, i + 1, index, nums)
        index-=1