Introduction

A permutation is an ordering of items where position matters. Generating permutations is a common task in combinatorics, brute-force search, test generation, and interview-style algorithm problems. The right technique depends on whether you need all permutations, just one random permutation, or a lazy sequence you can iterate without storing everything at once.

Generate all permutations with a library

If you are using Python, the simplest solution is usually itertools.permutations. It produces permutations lazily, which is much better than building a giant list unless you truly need all results in memory.

1from itertools import permutations
2
3items = ["a", "b", "c"]
4
5for perm in permutations(items):
6    print(perm)

This prints:

• '('a', 'b', 'c')'
• '('a', 'c', 'b')'
• '('b', 'a', 'c')'
• and so on

The big advantage is that you do not have to reimplement a standard algorithm for a common task.

Backtracking algorithm

If you need to understand or implement the logic yourself, backtracking is the classic method. At each step, choose one unused element, add it to the current path, recurse, then undo the choice.

1def generate_permutations(items):
2    result = []
3    used = [False] * len(items)
4    path = []
5
6    def backtrack():
7        if len(path) == len(items):
8            result.append(path.copy())
9            return
10
11        for i, item in enumerate(items):
12            if used[i]:
13                continue
14
15            used[i] = True
16            path.append(item)
17            backtrack()
18            path.pop()
19            used[i] = False
20
21    backtrack()
22    return result
23
24
25print(generate_permutations([1, 2, 3]))

This method is easy to reason about and adapts well when you need to add extra constraints, such as "only permutations where adjacent elements differ."

Generate one random permutation

Sometimes you do not need all permutations at all. You just need one shuffled ordering. In that case, generate a random permutation instead of enumerating the factorial-sized search space.

1import random
2
3items = [1, 2, 3, 4, 5]
4random.shuffle(items)
5
6print(items)

That is far cheaper than generating every possible arrangement and choosing one.

Understand the growth rate

The number of permutations of n distinct items is n!, which grows very quickly:

• '3! = 6'
• '5! = 120'
• '10! = 3,628,800'

This matters because a solution that feels fine for n = 5 becomes impractical much sooner than many people expect. The algorithm is not necessarily bad; the search space itself is large.

Avoid duplicates when input contains repeated values

If the input contains duplicate elements, naive generation can emit the same permutation more than once. For example, [1, 1, 2] has fewer unique permutations than three distinct elements would.

One fix is to sort the input and skip duplicate choices at the same decision level.

1def unique_permutations(items):
2    items = sorted(items)
3    result = []
4    used = [False] * len(items)
5    path = []
6
7    def backtrack():
8        if len(path) == len(items):
9            result.append(path.copy())
10            return
11
12        for i in range(len(items)):
13            if used[i]:
14                continue
15            if i > 0 and items[i] == items[i - 1] and not used[i - 1]:
16                continue
17
18            used[i] = True
19            path.append(items[i])
20            backtrack()
21            path.pop()
22            used[i] = False
23
24    backtrack()
25    return result

This version avoids duplicate outputs while still using the same backtracking idea.

Common Pitfalls

The first pitfall is materializing every permutation when you only need to iterate through them. Prefer lazy generation when possible.

Another issue is forgetting the factorial growth rate. A function that looks correct can still be unusable on slightly larger input sizes.

Duplicate inputs are another trap. Without duplicate-aware logic, your algorithm may generate repeated answers and waste a lot of time.

Finally, do not reimplement a library solution unless you need custom behavior or you are solving the problem for learning purposes.

Summary

• Use a library helper such as itertools.permutations when available.
• Use backtracking when you need to understand or customize the generation logic.
• Use random.shuffle when you need one random ordering, not every permutation.
• Watch out for factorial growth because permutations become expensive very quickly.
• Handle duplicate input values explicitly if you need unique permutations only.