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

欲彻底地测试一个字符串匹配算法，命名myAlgo（CHAR []一，CHAR [] B）爪哇：测试算法：所有可能的组合

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

我还没有能够计算的东西，会产生大小为n和字母l的数组的每个组合，否则我能够使代码能够将计算组合到迭代测试用例中（测试所有的两个数组的组合被比较），尽管代码能够生成组合，但是嵌套的for-loop应该执行所需的测试。

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

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; 
}

来源

2014-11-14 user3711518

这是很不清楚你在问什么 - 我也没有看到所有的变化可能和位翻转算法（但我不知道算法相当好）之间的连接。 – JBA 2014-11-14 15:08:17

更新，感谢您的反馈 – user3711518 2014-11-14 15:15:30

不客气 - 它已经更清晰你试图存档 - 因此我upvote让你回到正轨。现在你坚持在什么地方？像你有问题产生所有不同的组合？或者是你能够生成所有这些组合，但不知道如何从中动态生成测试用例？或者它既是组合以及调用已经工作，但你的'myAlgo'方法不能按预期工作？（在最后一种情况下，我们将不得不看到'myAlgo'方法，而在其他情况下，它不是真正的兴趣。 – JBA 2014-11-14 15:29:10

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

完成此操作的一种方法是订购您的字母（A = 0，B = 1，C = 2等）。然后，您可以从AAA ... AAA（n个字符长）的起始字符串中继续添加1.基本上，您实现了一个添加算法。加1会将A = 0变成B = 1。例如，n = 3和L = 3：

start：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，直到字符串中的所有元素都被刷新为止。

来源

2014-11-14 19:11:27 TravisJ

除了使用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，它应该仍然工作。当然，这可以进一步优化，但你应该明白。希望这个答案有帮助！

来源

2014-11-14 19:29:26 Kylorcache

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

回答

相关问题