Revision history [back]

One approach is to use a recursive function that computes all possible permutations. The function takes three arguments: the current permutation, the set of remaining items, and the handler function. At each step, the function loops over the remaining items, adding each to the current permutation and calling itself recursively with the updated permutation and the remaining items. Once all items have been used, the function calls the handler function with the current permutation.

Here's an example implementation in Python:

def permutations_helper(perm, items, handler):
    if not items:
        handler(perm)
    else:
        for i, item in enumerate(items):
            rest = items[:i] + items[i+1:]
            permutations_helper(perm + [item], rest, handler)

def permutations(items, handler):
    permutations_helper([], items, handler)

The permutations function is the entry point. It calls permutations_helper with an empty permutation and the full set of items. The permutations_helper function does the heavy lifting. If there are no remaining items, it calls the handler with the current permutation. Otherwise, it loops over the remaining items, adds each to the current permutation, and recursively calls itself with the updated permutation and the remaining items.

The handler function could be anything that takes a permutation as input, such as a function that prints the permutation or adds it to a list. Here's an example usage:

def print_permutation(perm):
    print(perm)

permutations([1, 2, 3], print_permutation)

This would output:

[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]

Note that this approach has exponential time complexity in the number of items, so it may not be practical for large sets. In such cases, level caching or other optimization techniques may be necessary.