All Possible Combinations of a String in Java

One of the most popular programming problems is to create every conceivable string combination. There are a few ways to do this with Java, including repetition, and recursion. We will examine many approaches to producing every possible combination of a given string in this section.

Method 1: Using Recursion

AllCombinations.java

public class AllCombinations {
    public static void main(String[] args) {
        String str = "abc";
        generateCombinations(str);
    }
    public static void generateCombinations(String str) {
        generateCombinations(str, "");
    }
    private static void generateCombinations(String remaining, String current) {
        if (remaining.isEmpty()) {
            System.out.println(current);
        } else {
            generateCombinationsHelper(remaining.substring(1), current + remaining.charAt(0));
            generateCombinationsHelper(remaining.substring(1), current);
        }
    }
}

Output:

abc
ab
ac
a
bc
b
c

Explanation

Recursion is used in this approach to produce every conceivable combination. Starting with the entire string, we build combinations at each step by adding or removing the initial character. We publish the current combination when the string remains empty. Until every possible combination is created, the recursion keeps going.

Method 2: Using Iteration

AllCombinations.java

import java.util.ArrayList;
import java.util.List;
public class AllCombinations {
    public static void main(String[] args) {
        String input = "abc";
        generateCombinations(input);
    }
    public static void generateCombinations(String input) {
        List<String> combinations = new ArrayList<>();
        int n = input.length();
        for (int j = 0; j < (1 << n); j++) {
            StringBuilder combination = new StringBuilder();
            for (int k = 0; k < n; k++) {
                if ((j & (1 << k)) != 0) {
                    combination.append(input.charAt(k));
                }
            }
            combinations.add(combination.toString());
        }
        for (String combo: combinations) {
            System.out.println(combo);
        }
    }
}

Output:

abc
ab
ac
a
bc
b
c

Method 3: Using Arrays

Combinations.java

public class Combinations {
    public static void printDistinctPermutations(String str, String ans) {
        if (str.length() == 0) {
            System.out.print(ans + " ");
            return;
        }
        boolean[] used = new boolean[26];
        for (int j = 0; j < str.length(); j++) {
            char ch = str.charAt(j);
            String remaining = str.substring(0, j) + str.substring(j+ 1);
            if (!used[ch - 'a']) {
                printDistinctPermutations(remaining, ans + ch);
            }
            used[ch - 'a'] = true;
        }
    }
    public static void main(String[] args) {
        String input = "abc";
        printDistinctPermutations(input, "");
    }
}

Output:

abc acb bac bca cab cba

Explanation

We construct a printDistinctPermutations function, which accepts as parameters the current permutation and the input string. We output the current permutation and return if the string is empty. The characters that have been utilized are tracked using a 26-character boolean array.

We go over the input string iteratively, making sure that every character has been used. If not, we update the used array to indicate that the character has been used and do a recursive call with the character deleted from the remaining string.

The input string "abc" is passed to printDistinctPermutations in the main procedure.

Method 4: Character Swapping

Combinations.java

public class Combinations{
    public static void printDistinctPermutations(String str, int left, int right) {
        if (left == right) {
            System.out.print(str + " ");
        } else {
            for (int j= left; j <= right; j++) {
                str = swap(str, left, j);
                printDistinctPermutations(str, left + 1, right);
                str = swap(str, left, j); 
            }
        }
    }
    public static String swap(String str, int x, int y) {
        char[] charArray = str.toCharArray();
        char temp = charArray[x];
        charArray[x] = charArray[y];
        charArray[y] = temp;
        return new String(charArray);
    }
    public static void main(String[] args) {
        String input = "abc";
        printDistinctPermutations(input, 0, input.length() - 1);
    }
}

Output:

abc acb bac bca cba cab

Explanation

The left index represents the character that starts, while the right index represents the character that finishes. If there is a permutation that results from the left index equalling the right index, we show the text.

If not, we swap the characters at the left index and the current index as we cycle over the characters in the string. The modified text and the left index, which has been increased by one, are then sent to a recursive function.

We retrace our steps by placing the characters in their initial locations after the recursive call to investigate other possibilities.

Characters in the string can be switched around using the swap technique.

Conclusion

These techniques provide several strategies for resolving the Java challenge of producing every conceivable string combination, accommodating various programming philosophies and tastes. We may select the approach that best meets your demands based on your unique requirements and available space.

Next TopicAtomic Reference in Java

← prev next →