Swift中允许重复元素的字符串全排列实现问询

Hey there! I totally get what you're struggling with here—you need all possible 3-element combinations where elements can be reused from your array, right? The standard permutation solutions that only give unique element combinations (like ABC, ABD) don't cover this case, and brute-force nested loops start to get clunky and inefficient, especially if you ever need to scale up the array size or the number of elements you want to pick.

Let me share some way better approaches than brute-force loops:

1. Use Your Language's Built-in Tools (Best for Efficiency) #

Most programming languages have optimized libraries that can generate these "with-replacement" combinations (technically, this is the k-fold Cartesian product of the array with itself) in a fraction of the time you'd spend writing nested loops.

For example, in Python, the itertools.product function is perfect for this—it's implemented in C under the hood, so it's way faster than any pure-Python loop you could write:

from itertools import product

input_arr = ["A", "B", "C", "D", "E"]
pick_count = 3

# Generate all tuples like ('A', 'A', 'A'), ('A', 'A', 'B'), etc.
raw_combinations = product(input_arr, repeat=pick_count)
# Convert tuples to strings if you need them in format like "AAA", "AAB"
formatted_combinations = [''.join(comb) for comb in raw_combinations]

print(formatted_combinations)

2. Recursive Implementation (Great for Flexibility) #

If you can't use built-in libraries, or need to add custom logic to the generation process, a recursive approach is way cleaner than writing 3+ nested loops (especially if pick_count might change later). Here's how that could look in Python:

def generate_repeating_combinations(arr, pick_count, current_str='', results=None):
    if results is None:
        results = []
    # Base case: we've picked all elements needed
    if pick_count == 0:
        results.append(current_str)
        return results
    # Recurse: add each element from the array to the current string, then pick one less element
    for char in arr:
        generate_repeating_combinations(arr, pick_count - 1, current_str + char, results)
    return results

input_arr = ["A", "B", "C", "D", "E"]
pick_count = 3
print(generate_repeating_combinations(input_arr, pick_count))

This works for any value of pick_count—no need to rewrite code if you later want 4 or 5-element combinations.

3. Optimized Iterative Approach (No Recursion Needed) #

If recursion isn't your thing, you can use an iterative method that builds up combinations step by step, avoiding deep nested loops:

def generate_iterative_repeating_combinations(arr, pick_count):
    combinations = ['']
    # For each position we need to fill
    for _ in range(pick_count):
        temp = []
        # Append each array element to every existing combination
        for combo in combinations:
            for char in arr:
                temp.append(combo + char)
        combinations = temp
    return combinations

input_arr = ["A", "B", "C", "D", "E"]
pick_count = 3
print(generate_iterative_repeating_combinations(input_arr, pick_count))

This is more maintainable than hardcoding 3 loops, and still way cleaner than brute-force.

Quick Summary #

• Go with built-in libraries first—they're the fastest and least error-prone.
• Use recursion or iterative builds if you need custom logic or can't rely on external libraries. Both are way better than brute-force nested loops for scalability and readability.

内容的提问来源于stack exchange，提问作者koen