a、b、c、d（长度4）与条件（java）的所有可能组合

所以我需要这个算法，但我似乎找不到问题所在。。。我需要打印出[a，b，c，d]（长度为4）的所有可能组合以及一些条件（已经在算法中）。那么我错过了什么？我在Java还是一个乞丐，所以非常感谢你的帮助

public class Test {

//Method saying that 'a' always have to follow 'b'
public static boolean aFollowsB(String s) {
      char[] set1 = s.toCharArray();

      for (int i = 0; i < set1.length; i++) {
        // If B is the last char, A can't possilby follow
        if (i == set1.length - 1) {
          if (set1[i] == 'b') { return false; }
        // Else if we encounter B, make sure next is an A
        } else {
          if (set1[i] == 'b') {
            if (set1[i+1] != 'a') { return false; }
          }
        }
      }

      return true;
    }

//Method saying that we can't have 'a' and 'd' in the same string
    public static boolean hasOnlyAOrD(String s) {
      char[] set1 = s.toCharArray();

      boolean hasA = false;
      boolean hasD = false;

      for (int i = 0; i < set1.length; i++) {
        if (set1[i] == 'a') {
          hasA = true;
        } else if (set1[i] == 'd') {
          hasD = true;
        }
      }

      if (hasA && hasD) {
        return false;
      }

      return true;
    }

//Method printAllKLength to print all possible strings of k lenght
    static void printAllKLength(char[] set, int k) { 
        int n = set.length;  
        printAllKLengthRec(set, "", n, k); 
    } 

    static void printAllKLengthRec (char[] set,  
                                   String prefix,  
                                   int n, int k) 
    { 

        if (k == 0)  {
            System.out.println(prefix); 
              System.out.println(prefix);
            return; 

        } 
        for (int i = 0; i < n; ++i) {
            String newPrefix = prefix + set[i];  
            printAllKLengthRec(set, newPrefix,  
                                    n, k - 1);  
        } 
    } 
    //Method to print with the conditions
    public static void main(String[] args) {
        char[] set1 = {'a', 'b', 'c', 'd'}; 
        int k = 4; 
        if (aFollowsB(set1) && hasOnlyAOrD(prefix)) {
            printAllKLength(set1, k); 
            }

公共类测试{
//表示“a”必须始终跟在“b”后面的方法
公共静态布尔AFOLOWSB（字符串s）{
char[]set1=s.toCharArray（）；
对于（int i=0；i

}}

编辑

好的，多亏了一些帮助，我把代码改成了一种更简单的方式，但是现在没有给我一个错误，它什么也没有给我。我不知道少了什么。 以下是新代码：

//// Méthode principale printAllKLength pour imprimer tous les strings possible de longueur k

static void printAllKLength(char[] set, int k) { 
    int n = set.length;  
    printAllKLengthRec(set, "", n, k); 
} 

static void printAllKLengthRec (char[] set,  
                               String prefix,  
                               int n, int k) 


{    if (k == 0)  {
    if  (aFollowsB(prefix) && hasOnlyAOrD(prefix) == true ) {
        System.out.println(prefix); 
        return; 

    } 
    for (int i = 0; i < n; ++i) {
        String newPrefix = prefix + set[i];  
        printAllKLengthRec(set, newPrefix,  
                                n, k - 1);  
    } }}



//Création de la méthode permettant de dire que 'a' doit toujours suivre 'b'

public static boolean aFollowsB(String str) {
    return str.indexOf('a') > str.indexOf('b');
}


    //Création de la méthode permettant de dire qu'on ne peut avoir 'a' et 'd' dans la même string
public static boolean hasOnlyAOrD(String str) {
    return str.indexOf('a') == -1 || str.indexOf('d') == -1;
}

//Création de la méthode principale

    public static void main(String[] args) {
    char[] set1 = {'a', 'b', 'c', 'd'}; 
    int k = 4; 
    printAllKLength(set1, k); 

///Méthode principale printAllKLength pull impimer to the les strings mable de longueur k
静态void printAllKLength（char[]集，int k）{
int n=设置长度；
printallklengtrec（set，“”，n，k）；
} 
静态void printallklengtrec（字符[]集，
字符串前缀，
整数n，整数k）
{if（k==0）{
if（aFollowsB（前缀）&&hasonlyord（前缀）==true）{
System.out.println（前缀）；
回来
} 
对于（int i=0；istr.indexOf（'b'）；
}
//这条线的长度和长度都很长
公共静态布尔值hasonlyord（字符串str）{
返回str.indexOf（'a'）=-1 | | str.indexOf（'d'）=-1；
}
//信条原则
公共静态void main（字符串[]args）{
char[]set1={'a'，'b'，'c'，'d'}；
int k=4；
打印所有长度（设置1，k）；

---

}}首先，修复PrintAllKlengtRec：

不要将所有内容打印两次（因此请删除其中一个system.out）：

然后，为每个结果调用afolowsb（不是在只调用一次的main方法中）：

这意味着AFOLOWSB将采用字符串参数，可能如下所示：

public static boolean aFollowsB(String str) {
    return str.indexOf('a') > str.indexOf('b');
}

最后，对HasOnlyOrd执行相同的操作（可能需要重命名该方法）

---

然后考虑使用“公共”和“静态”关键字少得多。但我想这超出了你的任务范围。

请描述问题（而不是说它不起作用）。所有

{a，b，c，d}

的组合都是a，b，c或d，后面跟着剩余字母的所有组合。谢谢@Stefan。我对我的问题进行了编辑，因为还有一些我不明白的地方。如果你格式化你的代码（在Eclipse中是ctrl+shift+f），你会看到在printAllKLengthRec中，for循环在k==0 If语句中，这是不应该的。你有一行和三行。将其中一个移到for语句上方，它就会工作。谢谢，所以我更改了这部分，但它给了我一个错误：{if（k==0）{if（afolowsb（prefix）&&hasonlyord（prefix）==true）{System.out.println（prefix）；return；}}for（int I=0；I线程“main”java.lang.StackOverflower中的异常在java.lang.AbstractStringBuilder.append（AbstractStringBuilder.java:449）
在java.lang.StringBuilder.append（StringBuilder.java:136）
在java.lang.StringBuilder.（StringBuilder.java:113）
在asass.A.printallklengtrec（A.java:26）
在asass.A.printallklengtrec（A.java:27）
最后一个被重复了很多。奇怪的是“return”语句在正确的位置。它应该在k==0 if语句中，但不在上述b&&hasonlyord if语句中。

static void printAllKLengthRec(char[] set, String prefix, int n, int k) {
    if (k == 0) {
        if (aFollowsB(prefix)) {
            System.out.println(prefix);
        }
        return;
    }
    ...

public static void main(String[] args) {
    char[] set1 = { 'a', 'b', 'c', 'd' };
    int k = 4;
    printAllKLength(set1, k);
}

public static boolean aFollowsB(String str) {
    return str.indexOf('a') > str.indexOf('b');
}

public static boolean hasOnlyAOrD(String str) {
    return str.indexOf('a') == -1 || str.indexOf('d') == -1;
}

static void printAllKLengthRec(char[] set, String prefix, int n, int k) {
    if (k == 0) {
        if (aFollowsB(prefix) && hasOnlyAOrD(prefix)) {
            System.out.println(prefix);
        }
        return;
    }
    ...