Generate all words using Java

I want to know how to generate all words using java f开发者_开发问答rom specified characters and length

String first[]={"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"};
String second[]={"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"};
String ch ="";  
String total[];

for(int i = 0;i<26;i++) {
    for(int j = 0;j<26;j++) {
        ch+=first[i]+first[j];
        System.out.println(ch);
    }
}

I get only 576 words only by this program, but the 26! words is 4.03291461 × 10^26

How to write the program in java?

public class Words {
    static char[] alphabet = "abcdefghijklmnopqrstuvwxyz".toCharArray();

    static void generate(StringBuilder sb, int n) {
        if (n == sb.length()) {
            System.out.println(sb.toString());
            return;
        }
        for (char letter : alphabet) {
            sb.setCharAt(n, letter);
            generate(sb, n + 1);
        }
    }
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int length = 2; length <= 5; length++) {
            sb.setLength(length);
            generate(sb, 0);
        }
    }
}

This generates all 2-letters, 3-letters, 4-letters, and 5-letters "words". It uses a standard recursive algorithm.

See also

• Given an array of integers [x0 x1 x2], how do you calculate all possible permutations from [0 0 0] to [x0 x1 x2]?

On a more mathematical note, people often confuse what the term "permutation" means. Yes, there are 26! permutations of the 26 letters a-z -- that's A LOT of strings, but this does not include aa, ab, etc. It includes all strings where the 26 letters each appear exactly once.

Consider what you're doing: you're looping through the first array once, and looping through the second once for each iteration through that loop. That's going to yield you a total of 26^2 results, or 676 (not 576). And the way you're constructing the output is very specific, check what you get and you'll notice a highly explicit pattern in there.

The second array of course is never used at all, so completely superfluous.

The solution is to write out on paper how you'd go about it were you to attempt it by hand, then attempt to translate that into code. For one you're not going to want to have only words of a specific length (which you get) or specific patterns of letters (which you also get).

but the 26! words is 4.03291461 × 1026

how to write the program in java

You don't write that program in Java or any other language. It would be pointless because it would literally take billions of years to finish.

But the number is also completely wrong for your intended result in the comments. 26! is the number of permutations, i.e. the different ways to order 26 elements without repetition. The number of words would be 26^n, where n is the length.

Here's my solution. It's kind of quick, so don't be too hard on the optimization.

public static void printWords(int length) {

    if (length < 1)
        throw new IllegalArgumentException();

    printWordsRec("", length);
}

private static void printWordsRec(String base, int length) {

    for (char c = 'a'; c <= 'z'; c++) {
        if (length == 1) {
            System.out.println(base + c);
        }
        else {
            printWordsRec(base + c, length - 1);
        }
    }
}