Question

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

详尽的测试包括否。不同的字母，alplhabet“l”，在“n”长数组中。然后测试计算所有组合，同时将它与具有相似属性的另一个数组的所有组合（如真值表）进行比较，例如

我无法计算能够生成大小为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”组）并且还会在以后的迭代中开始打印出奇怪的输出。

公共课测试{

//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"
    }
}

}

我的arrayflipper代码：

public char[] countArray(char[] a){
    int i=0;
    while(i<a.length){
        switch (a[i]){
        case 'A':
            a[i]='B';
            clearBottom(a,i);
            return a;
        case 'B':
            a[i]='C';
            clearBottom(a,i);
            return a;
        case 'C':
            a[i]='D';
            clearBottom(a,i);
            return a;
        case 'D':
            i++;
            break;
        default:
            System.out.println("Something went terribly wrong!");

        }
    }
    return a;

}
public char[] clearBottom(char [] a, int i){
    while(i >0){
        i--;
        a[i] = 'A';
    }
    return a;
}

Answer 1

据我所知，你的目标是创建所有n个字符的长字符串（单独存储为数组中的元素），由L字母表中的字母组成？

实现此目的的一种方法是订购你的字母（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），将ACAAA作为下一个字符串。

您的算法只重复加1，直到字符串中的所有元素都被最大化。

Answer 2

我建议不要使用switch语句，而是将要测试的每个字符（A，B，C，D）放入一个数组中，然后使用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);
    }
}

您可以向l添加更多字符以及增加n，它仍然有效。当然，这可以进一步优化，但你应该明白这一点。希望这个答案有所帮助！

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

2 个答案: