Java：测试算法：所有可能的组合

我想彻底测试一个名为myAlgo（Char[]a，Char[]b）的字符串匹配算法

穷举测试包括“n”长数组中不同字符的数量，alplhabet“l”。然后，测试计算所有组合，同时将其与具有类似属性（如真值表）的另一个数组的所有组合进行比较，例如：

我既不能计算出能够生成大小为n和字母l的数组的每个组合的东西，也不能生成能够将计算组合成迭代测试用例的代码（测试比较的两个数组的所有组合），尽管代码能够生成组合，但创建嵌套for循环应该能够完成所需的测试

我的目标是打破我的算法，让它计算一些不应该计算的东西

Test(char[] l, int n)
    l = [a;b] //a case could be
    n = 2     //a case could be
    myAlgo([a;a],[a;a]); //loops over my algorithm in the following way
    myAlgo([a;b],[a;a]);
    myAlgo([b;a],[a;a]);
    myAlgo([b;b],[a;a]);
    myAlgo([a;a],[a;b]);
    myAlgo([a;b],[a;b]);
    myAlgo([b;a],[a;b]);
    myAlgo([b;b],[a;b]);
    myAlgo([a;a],[b;a]);
    myAlgo([a;b],[b;a]);
    ...
    myAlgo([b;b],[b;b]);

我自己的解决方案（仅适用于有限的“l”）并在以后的迭代中开始打印wierd输出

公开课考试{

//aux function to format chars
public static String concatChar(char [] c){
    String s = "";
    for(char cc : c){
        s += cc;
    }
    return s;
}

public static void main(String[] args) {

    String ss1 = "AA";                          //TestCases, n = 2
    String ss2 = "AA";
    char[] test1 = ss1.toCharArray();
    char[] test2 = ss2.toCharArray();
    Fordi fordi = new Fordi();                  //my algorithm
    TestGenerator tGen = new TestGenerator();   //my testGenerator
    for(int i=0; i<Math.pow(4.0, 2.0);i++){     //to test all different cases

        for(int j=0; j<Math.pow(4.0, 2.0);j++){
            int k = fordi.calculate(test1, test2);  //my algorithm
            String mys1 = concatChar(test1);        //to print result
            String mys2 = concatChar(test2);        //to print result
            System.out.println(mys1 + " - " + mys2);
            System.out.println(k);
            test2 = tGen.countArray(test2);         //"flip" one number
        }
        test2 = ss1.toCharArray();
        test1 = tGen.countArray(test1);             //"flip"
    }
}

//格式化字符的辅助函数
公共静态字符串concatChar（char[]c）{
字符串s=“”；
用于（字符cc:c）{
s+=cc；
}
返回s；
}
公共静态void main（字符串[]args）{
字符串ss1=“AA”//TestCases，n=2
字符串ss2=“AA”；
char[]test1=ss1.toCharArray（）；
char[]test2=ss2.toCharArray（）；
Fordi Fordi=new Fordi（）；//我的算法
TestGenerator tGen=new TestGenerator（）；//我的TestGenerator
对于（inti=0；i据我所知，您的目标是创建由L字母表中的字母组成的所有n字符长字符串（作为数组中的元素单独存储）

实现这一点的一种方法是对字母进行排序（A=0、B=1、C=2等）。然后，您可以从AAA…AAA（n个字符长）的起始字符串继续添加1。实际上，您实现了一种加法算法。添加1会将A=0转换为B=1。例如，n=3和L=3：

起点：AAA（0,0,0）

添加1将成为AAB（0,0,1）

再次添加1将成为AAC（0，0，2）

再次添加1（因为我们没有字母了，现在我们携带了一点）ABA（0，1，0）

你可以把这个过程归结为寻找最右边的没有最大化的数字，然后加上1（然后该数字右边的所有数字都归零）。因此在字符串ABCCC中，B数字是最右边的没有最大化的数字，它上升1，变成C，然后右边所有最大化的数字都返回0（a）留下ACAA作为下一个字符串

您的算法只是重复地添加1，直到字符串中的所有元素都被最大化。
我建议您将要测试的每个字符（a、B、C、D）都放入switch语句，而不是使用switch语句输入数组，然后使用XOR操作从迭代数中计算每个字符的索引，方法类似于以下内容：

char[] l = new char[]{'A','B','C','D'};
int n = 2;
char[] test1 = new char[n];
char[] test2 = new char[n];
int max = (int)Math.pow(l.length, n);
for (int i = 0; i < max; i++) {
    for (int k = 0; k < n; k++) {
        test2[k] = l[(i % (int)Math.pow(l.length, k + 1)) / (int)Math.pow(l.length, k)];
    }
    for (int j = 0; j < max; j++) {
        for (int k = 0; k < n; k++) {
            test1[k] = l[(j % (int)Math.pow(l.length, k + 1)) / (int)Math.pow(l.length, k)];
        }
        int k = fordi.calculate(test1, test2);
        System.out.println(new String(test1) + "-" + new String(test2));
        System.out.println(k);
    }
}

char[]l=new char[]{'A'，'B'，'C'，'D'}；
int n=2；
char[]test1=新字符[n]；
char[]test2=新字符[n]；
int max=（int）数学功率（l.长度，n）；
对于（int i=0；i

你可以在
l
中添加更多字符，也可以增加
n
字符，这应该仍然有效。当然，这可以进一步优化，但你应该明白。希望这个答案有帮助！
你问的问题非常不清楚-我也不认为所有可能的变化与位翻转alg之间有什么联系算法（但我对算法不太了解）.更新，感谢反馈欢迎您-您试图归档的内容已经非常清楚-因此我向您投了一票，希望您重新回到正轨。现在，您到底在哪里？您在生成所有不同的组合时遇到了问题吗？还是您能够生成所有这些组合，但不知道如何动态生成或者是组合和调用都已经工作了，但是您的
myAlgo
方法没有按预期工作？（在最后一种情况下，我们将不得不看到
myAlgo
方法，而在其他情况下，它并不真正感兴趣。前两种，我已将其添加到帖子中。谢谢，我不知道这一点。
char[] l = new char[]{'A','B','C','D'};
int n = 2;
char[] test1 = new char[n];
char[] test2 = new char[n];
int max = (int)Math.pow(l.length, n);
for (int i = 0; i < max; i++) {
    for (int k = 0; k < n; k++) {
        test2[k] = l[(i % (int)Math.pow(l.length, k + 1)) / (int)Math.pow(l.length, k)];
    }
    for (int j = 0; j < max; j++) {
        for (int k = 0; k < n; k++) {
            test1[k] = l[(j % (int)Math.pow(l.length, k + 1)) / (int)Math.pow(l.length, k)];
        }
        int k = fordi.calculate(test1, test2);
        System.out.println(new String(test1) + "-" + new String(test2));
        System.out.println(k);
    }
}