Question

Since I’m not that familiar with java, I don’t know if there’s a library somewhere that can do this thing. If not, does anybody have any ideas how can this be accomplished?

For instance I have a string “foo” and I want to change the letter f with “f” and “a” so that the function returns a list of strings with values “foo” and “aoo”.

How to deal with it when there’s more of the same letters? “ffoo” into “ffoo”, “afoo”, “faoo”, “aaoo”.

A better explanation:
((“a”,(“a”,”b)),(“c”,(“c”,”d”)))
Above is a group of characters that need to be replaced with a character from the other element. “a” is to be replaced with “a” and with “b”. “c” is to be replaced with “c” and “d”.

If I have a string “ac”, the resulting combinations I need are:
“ac”
“bc”
“ad”
“bd”

If the string is “IaJaKc”, the resulting combinations are:
“IaJaKc”
“IbJaKc”
“IaJbKc”
“IbJbKc”
“IaJaKd”
“IbJaKd”
“IaJbKd”
“IbJbKd”

The number of combinations can be calculated like this:
(replacements_of_a^letter_amount_a)*(replacements_of_c^letter_amount_c)
first case: 2^1*2^1 = 4
second case: 2^2*2^1 = 8

If, say, the group is ((“a”,(“a”,”b)),(“c”,(“c”,”d”,”e”))), and the string is “aac”, the number of combinations is:
2^2*3^1 = 12

Answer 1

Here it is:

public static void returnVariants(String input){
        List<String> output = new ArrayList<String>();
        StringBuffer word = new StringBuffer(input);
        output.add(input);

        String letters = "ac";
        int lettersLength = letters.length();
        int wordLength = word.length();
        String replacement = "";

        for (int i = 0; i < lettersLength; i++) {
            for (int j = 0; j < wordLength; j++) {
                if(word.charAt(j)==letters.charAt(i)){
                    if (word.charAt(j)=='a'){
                        replacement = "ab";
                    }else if (word.charAt(j)=='c'){
                        replacement = "cd";
                    }
                    List<String> tempList = new ArrayList<String>();
                    for (int k = 0; k < replacement.length(); k++) {
                        for (String variant : output){
                            StringBuffer tempBuffer = new StringBuffer(variant);
                            String combination = tempBuffer.replace(j, j+1, replacement.substring(k, k+1)).toString();
                            tempList.add(combination);
                        }
                    }
                    output.addAll(tempList);
                    if (j==0){
                        output.remove(0);
                    }
                }
            }
        }
        Set<String> uniqueCombinations = new HashSet(output);
        System.out.println(uniqueCombinations);
    }

If input is “ac”, the combinations returned are “ac”, “bc”, “ad”, “bd”. If it can be optimized further, any additional help is welcome and appreciated.