1

在搜索网络和此站点后，我无法找到解决问题的确切方法。

我想生成一个以'a'开头的列表并以以下方式迭代：a，b，c，aa，ab，ac，ba，bb，bc，ca，cb，cc，aaa ...

我想指定 2 个变量，一个将被迭代的字符串和一个显示结果的最大长度/深度的整数。我希望能够将字符串更改为我喜欢的任何内容和任何长度。

String alpha = "abcdefghijklmnopqrstuvwxyz0123456789";
int depth = 6;

我希望我对答案足够具体。谢谢！

4

5 回答 5

2

这是你需要的。如果你想用蛮力。

 public static void combin(String input,StringBuffer output,int depth){
      if (depth == 0) {
            System.out.println(output);
        } else {
            for (int i = 0; i < input.length(); i++) {
                output.append(input.charAt(i));
                combin(input, output,depth - 1);
                output.deleteCharAt(output.length() - 1);
            }
        }    
 }
于 2013-06-05T02:18:38.227 回答
0

您正在寻找的是递归！这是计算机科学中我最喜欢的主题之一，因此请在此处查看：http ://en.wikipedia.org/wiki/Recursion_%28computer_science%29该函数通过调用自身来创建循环。

String recurse(String dataSet, String current, int limit) {
    // iterate through each character to add to the word
    for (int i=0; i<dataSet.length(); i++) {
        // print the current character along with the total behind it
        System.out.println(current + dataSet.charAt(i));
        // stop if you reach the length limit
        if (current.length() < limit) {
            // start again with each set of data
            recurse(current + dataSet.charAt(i));
        }
    }
}

recurse("abc", "", 5);
于 2013-06-05T02:30:39.193 回答
0

显然，使用递归，我们能够以相当短的形式编写它。该函数接受一些集合（我在此示例中使用了一个集合），而不是创建多个对象以减少内存开销。

public static void main(String[] args) {
    Set<String> set = new TreeSet<String>();
    GenerateUniques(set, "", "abcdefghijklmn", 6);
    System.out.println(set.size());
}

private static void GenerateUniques(Collection<String> coll, String prefix, String chars, int depth) {
    if (depth-- == 0) return;
    for (int i = 0; i < chars.length(); i++) {
        String str = prefix + chars.charAt(i);
        coll.add(str);
        GenerateUniques(coll, str, chars, depth);
    }
}
于 2013-06-05T02:35:51.757 回答
0

您可以使用递归轻松解决此问题：

List<String> product(String chars, int length) {
    List<String> res = new ArrayList<String>();
    res.add("");
    if (length > 0) {
        for (c : chars) {
            res.addAll(product(chars, length - 1) + c);
        }
    }
    return res;
}

对于您给定的字符串和长度，此列表将非常大（约 20 亿个条目）。

于 2013-06-05T02:19:08.030 回答
0

想象一下最大长度强度中的每个字符都是一个“不倒翁”，就像模拟计数器的不倒翁（回到我们使用计算机之前！）。不倒翁的侧面有 -1, 0, 1, 2... 并且还具有以下属性：当它从 -1 开始时（0 表示最右边的一个），当它从 MAX 开始时，它会变为 0 而不是-1，并且它还会在它左边的杯子打勾一次（如果它也溢出，它也可以在它左边的杯子打勾一次，依此类推）

现在，我们有一个这样的算法：

1）初始化一个整数列表：-1，-1，-1...0，depth总共。将这些称为计数器。

2) 增加最右边的计数器。

3）现在是棘手的部分。保留一个整数变量，指示我们当前正在处理的计数器，调用它idx = depth-1。如果我们递增的计数器溢出，那么不要跳过这一步，而是递减idx并将1新指向的计数器标记为 1。在一个循环中，检查是否也溢出，如果是，则循环它并向上移动一个计数器，等等，直到我们要么idx向左移动它超过 0（如果是这样，返回，我们已经打印出所有组合并循环）或者不溢出计数器。

4）打印出与列表索引对应的字符串alpha（如果为-1，则不添加任何内容）。

于 2013-06-05T02:16:30.870 回答