求给定字符串指定长度范围的排列组合及结果数量公式

首先得纠正你之前的一个认知错误：你原本以为结果数量是∑(3! + 4! + … + n!)，这其实不对。因为我们是从原字符串的m个不同字符中选k个进行排列，而不是对k个固定字符排列。正确的排列数应该用排列公式P(m, k) = m!/(m-k)!，也就是从m个元素里选k个的有序排列数。

举个实际例子，比如输入是abcde（m=5），min=3，max=5：

• 长度3的排列数：5×4×3=60（而不是3! =6）
• 长度4的排列数：5×4×3×2=120
• 长度5的排列数：5!=120
  所以总结果数是60+120+120=300，对应的公式就是∑(P(m, k)) 其中k从min到max（max不能超过m，因为原字符串只有m个不同字符，没法生成更长的不重复排列）。

接下来给你不同语言的实现方案：

JavaScript 实现 #

这个实现用回溯法手动生成排列，适合理解底层逻辑：

function allCombos(str, min, max) {
    const chars = str.split('');
    const charCount = chars.length;
    // 防止max超过原字符串长度，毕竟没法用重复字符生成更长的不重复排列
    const actualMax = Math.min(max, charCount);
    if (min > actualMax || min < 1) return [];

    const result = [];

    // 回溯函数：current是当前正在构建的排列，used标记哪些字符已经被使用
    function buildPermutations(current, used) {
        const currentLength = current.length;
        // 如果当前长度在min到actualMax之间，就加入结果
        if (currentLength >= min && currentLength <= actualMax) {
            result.push(current.join(''));
        }
        // 已经到最大长度了，停止递归
        if (currentLength === actualMax) return;

        for (let i = 0; i < charCount; i++) {
            if (!used[i]) {
                used[i] = true;
                current.push(chars[i]);
                buildPermutations(current, used);
                // 回溯：撤销选择
                current.pop();
                used[i] = false;
            }
        }
    }

    buildPermutations([], Array(charCount).fill(false));
    return result;
}

// 测试：输出应该是300
console.log(allCombos('abcde', 3, 5).length);

Python 实现 #

Python可以直接用标准库的itertools.permutations，代码更简洁：

from itertools import permutations

def allCombos(s: str, min_len: int, max_len: int) -> list[str]:
    char_list = list(s)
    total_chars = len(char_list)
    actual_max = min(max_len, total_chars)
    if min_len > actual_max or min_len < 1:
        return []
    
    result = []
    # 遍历从min到actual_max的所有长度
    for length in range(min_len, actual_max + 1):
        # 生成所有该长度的排列，转为字符串后加入结果
        for perm in permutations(char_list, length):
            result.append(''.join(perm))
    
    return result

# 测试：输出300
print(len(allCombos('abcde', 3, 5)))

伪代码（通用逻辑） #

如果需要自己实现底层逻辑，伪代码可以帮你理清思路：

function allCombos(string, minLength, maxLength):
    characters = split string into an array of individual characters
    totalChars = length of characters
    actualMax = minimum of maxLength and totalChars
    if minLength > actualMax or minLength < 1:
        return empty array
    
    result = empty array

    function backtrack(currentPermutation, usedFlags):
        currentLen = length of currentPermutation
        if currentLen >= minLength and currentLen <= actualMax:
            add joined(currentPermutation) to result
        if currentLen == actualMax:
            return
        
        for i from 0 to totalChars - 1:
            if usedFlags[i] is false:
                set usedFlags[i] to true
                add characters[i] to currentPermutation
                backtrack(currentPermutation, usedFlags)
                remove last element from currentPermutation
                set usedFlags[i] to false
    
    backtrack(empty array, array of totalChars false values)
    return result

额外说明 #

• 上面的实现默认原字符串中的字符都是唯一的。如果你的字符串有重复字符，生成的结果会包含重复的排列。如果需要去重，可以在最后对结果集合进行去重（比如JS用[...new Set(result)]，Python用list(set(result))，但注意去重会打乱原有顺序）。
• 当原字符串长度较大时，排列数会指数级增长，可能导致内存或性能问题，这时候要考虑是否真的需要生成所有排列，或者有没有更高效的处理方式。

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