# Alle möglichen Stringkombinationen aus bestimmtem Alphabet erzeugen



## DarkMaster3960 (26. Mrz 2010)

Guten Abend,

//edit: aktueller Stand: click =)

ich habe ein Alphabet der Form "abcdefghijklmnopqrstuvwxyz" gegeben.

Jetzt habe ich noch die max. Länge von 4 gegeben.

Nun würde ich gerne alle möglichen Wörter bis zur Länge 4 damit erzeugen, also ca. so:

a,b,c,d,[...]
aa,ab,ac,ad,ae,af,ag,[...]
ba,bb,bc,bd,be,[...]
aaaa,aaab,aaac,[...]

ich habe das ganze schon mit 2 Array und Zählschleifen begonnen, komme aber noch nicht ganz hinter eine Funktionierende Logik...

Das Alphabet habe ich als charArray und auch das aktuelle Wort lasse ich mit als charArray mit der Methode toString() ausgeben.

Diese Logik dürfte absolut nicht stimmen, aber:


```
for(int i = 0; i<length; i++) {
					actWord = new char[i+1];
					for(int j = 0; j<alphabet.length; j++) {
						for(int k = 0; k<actWord.length; k++) {
							actWord[k] = alphabet[j];
                            System.out.println(actWord.toString());
						}
					}
				}
```

Vielleicht bin ich heute einfach wieder zu lange am Rechner gewesen und ein wenig unkonzentriert...

MfG DM :rtfm:


----------



## DarkLegend (26. Mrz 2010)

nimm doch einfach 4 schleifen


```
for(int a = 0; a<length; a++) {
   System.out.println(alphabet[a]);
   for(int b = 0; b<length; b++) {
      System.out.println(alphabet[a]+alphabet[b]);
      for(int c = 0; c<length; c++) {
          System.out.println(alphabet[a]+alphabet[b]+alphabet[c]);
         for(int d = 0; d<length; d++) {
                System.out.println(alphabet[a]+alphabet[b]+alphabet[c]+alphabet[d]);
          }
      }
    }
}
```


----------



## DarkMaster3960 (26. Mrz 2010)

Genial, Danke =)

xD:applaus:

öhm, eine Frage hab ich noch...

Wie mache ich das dynamisch für eine beliebige Länge?

also bspw möchte ich alle von länge 1 - 16?


----------



## faetzminator (26. Mrz 2010)

So was  ?

```
public class Foo {

    public static void main(String[] args) {
        printCombinations("abcdefghijklmnopqrstuvwxyz".toCharArray(), 3);
    }

    private static void printCombinations(char[] chars, int length) {
        for (int len = 1; len <= length; len++) {
            printCombinations(chars, len, new char[len], 0);
        }
    }

    private static void printCombinations(char[] chars, int length, char[] combination, int index) {
        if (index == length) {
            System.out.println(String.valueOf(combination));
        }
        else {
            for (char c : chars) {
                combination[index] = c;
                printCombinations(chars, length, combination, index + 1);
            }
        }
    }
}
```


----------



## DarkLegend (26. Mrz 2010)

Das ist natürlich etwas trickreicher 
Rekursion ist da dann das Zauberwort.


```
public void ausgabe(int stufe, String wort) {
   for(int a = 0; a<length; a++) {
       System.out.println(wort+alphabet[a]);
       if(stufe > 0) 
           ausgabe(stufe-1,wort+alphabet[a])
   }
}
```

allerdings garantiere ich dir, dass es bei deinem großen alphabet niemals alle kominationen bis länge 16 erstellen können wirst


----------



## DarkMaster3960 (27. Mrz 2010)

Ich bin euch echt dankbar für eure Hilfe, aber ich glaub ich steh aufm Schlauch...

Ich würde gern jeden String der entsteht nutzen, leider wirft das ganze noch ein paar Fehler:


```
public void generateString_1 (char[] pAlphabet, int pLength) {
        char[] word;
        String finalWord;
        for(int i=1; i<=pLength; i++) {
            word = new char[i];
            for(int j=0; j<i; j++) {
                for(int k=0; k<pAlphabet.length; k++) {
                    word[j] = pAlphabet[k];
                    //computation
                    finalWord = "";
                    for(int l = 0; l<word.length; l++) {
                        finalWord += Character.toString(word[l]);
                    }
                    System.out.println(finalWord);
                }
            }
        }
    }
```


----------



## 0x7F800000 (27. Mrz 2010)

ich hatte es irgendwann mal satt, diese kombinatorik-algos immer wieder auf's neue ausimplementieren zu müssen. Wenn ich das will, was du beschrieben hast, schreib ich jetzt folgendes:

```
Iterable<String> i = new MappedIterable<String>(
		new MultiIterable<List<Character>>(
				range(1,5),
				new Function<Integer,Iterable<List<Character>>>(){
					@Override public Iterable<List<Character>> eval(final Integer i){
						return SetMath.getCombinations(alphabet,i);
					}
				}
		),
		new Function<List<Character>,String>(){
			@Override public String eval(List<Character> list){
				String s=""; for(char c:list) s+=c; return s;
			}
		}
);
```
keine schleifen keine rekursionen, keine OutOfMemory-Fehler, alles vollkommen Typsicher :smoke:


----------

