# Java-Programm Zahlenkombinationen ausgeben



## LollyXOXO (27. Okt 2015)

Hallo Leute, 
wir müssen ein Java-Programm schreiben bei dem alle möglichen Zahlenkombinationen von 1 2 3 und 4 ausgegeben werden sollen. Im Programm soll 1=a, 2=b, 3=c und 4=d sein... Mir ist klar dass es 24 Kombinationsmöglichkeiten gibt und dass es am leichtesten mit einer Rekursion und if-Schleifen geht.
Als Ergebnis sollen nun alle 24 Möglichkeiten untereinander ausgegeben werden und KEINE darf doppelt vorkommen oder ausgelassen werden. 

Ich habe aber leider keine Ahnung wie der Ansatz ist ... mir würde auch schon ein Pseudocode reichen und danke im Voraus


----------



## strußi (27. Okt 2015)

schachtel vier for-schleifen und lass dir in der innersten die ausgabe von allen vieren geben damit bekommst du alle möglichen kombinationen, aber leider auch die mit doppelten werten, die kannst du über if-abfragen filtern
a!=b &&a !=c &&a !=d ...


----------



## LollyXOXO (27. Okt 2015)

danke aber was muss ich in die vier schleifen jeweils reinschreiben?


----------



## klauskarambulut (28. Okt 2015)

```
public class Kombinationen {

    private static List<String> combine(List<Integer> n) {
        List<String> result = new ArrayList<>();
        if (n.isEmpty()) {
            result.add("");
        } else {
            n.stream().forEach((i) -> {
                List<Integer> temp = new ArrayList<>(n);
                temp.remove(i);
                List<String> strings = combine(temp);
                strings.stream().forEach((s) -> {
                    result.add(i + s);
                });
            });
        }
        return result;
    }

    public static void main(String[] args) {
        Stream.of(Arrays.asList(1, 2, 3, 4))
                .map(Kombinationen::combine)
                .forEach(r -> r.stream().forEach(System.out::println));
    }
}
```


----------



## Madlip (28. Okt 2015)

@klauskarambulut ein hoch auf Lambdas 

Gefällt mir richtig gut, nur hab ich da meine Zweifel das der Thread-Ersteller das ganze nachvollziehen kann. Ich muss gestehen das ich jetzt auch ein bisschen gebraucht habe.

Aber trotzdem, noch einmal, gefällt mir richtig gut!


----------



## Thallius (28. Okt 2015)

Madlip hat gesagt.:


> @klauskarambulut ein hoch auf Lambdas
> 
> Gefällt mir richtig gut, nur hab ich da meine Zweifel das der Thread-Ersteller das ganze nachvollziehen kann. Ich muss gestehen das ich jetzt auch ein bisschen gebraucht habe.
> 
> Aber trotzdem, noch einmal, gefällt mir richtig gut!



Naja mich erinnert das eher an die alten Zeiten wo wir aus Spaß ganze Programme in einer Zeile in C geschrieben haben. Ohne den Code zu dokumentieren muss man lange hinsehen bis man kapiert was es macht. Das finde ich zwar interessant aber produktiv ist es deswegen noch lange nicht. 

Gruß

Claus


----------



## X5-599 (28. Okt 2015)

Ich kann dem ganzen Lambda Krams nichts abgewinnen. Gar nichts. Man sieht nicht mehr was wirklich geschieht. Das schöne an Java ist (war), dass wenn man sich an die Code-Conventions hält man SOFORT sieht was eine Klasse, Methode, Objekt, Klassen-Methodenaufruf ist.
Vorteil ohne Lambda ist, man kann den Code jedem Programmieren vorsetzen. Egal ob Profi oder Anfänger.


----------



## Flown (28. Okt 2015)

Also ich muss sagen das Lambda-Kalkül der Grundstein einer jeden Programmiersprache ist und mMn zu wenig Beachtung geschenkt wird. Zu sagen, dass es unlesbarer wird würde ich nicht behaupten, denn ist ja eine kompakte schreibweise einer Funktion - es ist reine Gewöhnungssache.


----------



## strußi (28. Okt 2015)

Du brauchst vier for-schleifen die jeweils von 1 bis <=4 gehen



Spoiler: fertige ausgabe





```
for( int a=1; a<=4; a++ ){
               for( int b=1; b<=4; b++ ){
                    for( int c=1; c<=4; c++ ){
                         for( int d=1; d<=4; d++ ){
                              if( a!=b&&a!=c&&a!=d
                                  &&b!=c&&b!=d
                                  &&c!=d ){
                                   System.out.println( a+" "+b+" "+c+" "+d );
                              }
                         }
                    }

               }
          }
```


----------



## Neumi5694 (2. Nov 2015)

Will man auf Abfragen verzichten, dann geht's auch so:

```
private static List<String> combineToString(List theList) {
        if (theList.size() == 1) {
            return Arrays.asList(theList.get(0).toString());
        } else {
            List<String> result = new ArrayList<>();
            for (Object oneVal : theList) {
                String firstN = oneVal.toString();
                ArrayList newList = new ArrayList<>(theList);
                newList.remove(oneVal);
                for (String oneResult : combineToString(newList)) {
                    result.add(firstN + ", " + oneResult);
                }
            }
            return result;
        }
    }
```
oder - falls man etwas anderes als eine String-Ausgabe will:

```
private static List<List> combineToList(List theList) {
        if (theList.size() == 1) {
            return Arrays.asList(new ArrayList(Arrays.asList(theList.get(0))));
        } else {
            List<List> result = new ArrayList<>();
            for (Object oneVal : theList) {
                String firstN = oneVal.toString();
                ArrayList newList = new ArrayList<>(theList);
                newList.remove(oneVal);
                for (List oneResult : combineToList(newList)) {
                    ((ArrayList)oneResult).add(0, firstN);
                    result.add(oneResult);
                }
            }
            return result;
        }
    }
```

Die Fehlerbehandlung, falls theList.size()==0 oder theList == null ist, fehlt natürlich noch.


----------



## Dompteur (2. Nov 2015)

Da die Aufgabenstellung nur die Ausgabe der Strings fordert, kann man das obige Beispiel vereinfachen. Ich verwende auch keine Liste, sondern einen String, dessen Buchstaben permutiert werden.
Hier das vollständige Programm:

```
public class Zahlenkombi {
 
    public static void main(String[] args) {
        permutiere ("abcd");
    }
 
    private static void permutiere (String str) {
        permutiere ("", str);
    }
   
    private static void permutiere (String prefix, String rest) {
        if ( rest.length() == 1) {
            System.out.println (prefix + rest);
        } else {
            for (int i=0; i<rest.length();i++) {
                permutiere (prefix + rest.charAt(i), removeChar ( rest, i) );
            }
        }
    }
   
    private static String removeChar ( String str, int pos ) {
        return str.substring(0, pos) + str.substring(pos+1, str.length());
    }
}
```


----------

