# Brute-Force-Methode mit boolean



## nichtkarim (17. Nov 2022)

Hallo,

es gibt eine Aufgabe bei der ich nun wirklich nicht weiterkomme. Ich verstehe an sich wie tiefe Schleifen funktionieren, bin bei der Aufgabe jedoch Ratlos.
Kann mir da jemand helfen?

Selbst die Tipps unter der Aufgabenstellung haben mir dabei nicht großartig geholfen. Danke im Vorraus.








Großes Verletzungspech zwingt den Bundestrainer der deutschen Fußballnationalmannschaft vor ei- nem WM-Spiel gegen Italien (gegen das sie in einer WM noch nie gewonnen hat), gleich drei Spieler von der Reservebank einzusetzen. Fünf Spieler kommen dabei in Betracht, und der Trainer setzt sich mit seinem Assistenten zusammen, der ihm Folgendes zu bedenken gibt:


_Da hätten wir zunächst Al, einen wirklich guten Stürmer, der aber manchmal etwas über- heblich spielt. Du solltest auf jeden Fall Cid einsetzen, falls Al spielt, Cid ist der ruhende Pol bei uns, er sorgt dafür, dass die Jungs auf dem Teppich bleiben. Das gilt besonders für Daniel, wenn Du den einsetzt, darf Cid auf keinen Fall fehlen. 


Bloß, seitdem Bert Daniels Freundin ausgespannt hat, sind die beiden überhaupt nicht gut aufeinander zu sprechen. Daniel und Bert sollten also auf keinen Fall in einer Mann- schaft spielen. Willst Du aber Bert einsetzen, so muss auf jeden Fall Ernie spielen. Ernie und Bert sind ein Superteam, ihr Kombinationsspiel ist traumhaft. _

Da der Bundestrainer sich nicht erneut taktisch ausmanövrieren lassen will, möchte er eine systema- tische Aufstellung aller ratsamen Kombinationen von drei Einwechselspielern, und zwar vom Com- puter berechnet.


Aufgabenstellung. Schreiben Sie dem Bundestrainer eine Applikation, die sämtliche ratsamen Drei- erkombinationen der 5 Reservespieler ausgibt.


Testfälle. Es gibt nur zwei ratsame Spielerkombinationen: (Bert, Cid, Ernie) und (Al, Cid, Daniel). Tipps. Wenn Sie stocken oder nicht weiter wissen:



Verwenden Sie dazu für jeden Spieler eine eigene Boole’sche Variable, also z.B. al für den Spieler Al, wobei deren Wert false bedeutet, dass Al nicht spielt, und true, dass er spielt.
Eine eigene Boole’sche Variable zur Ermittlung einer ratsamen Spielerkombination ist vorteil- haft.
Sie brauchen 5 verschachtelte Schleifen.
Jeder Hinweis des Assistenten entspricht einer logischen Aussage, die z. B. als if-Bedingung programmiert werden kann. Eine weitere Bedingung muss sein, dass genau 3 Spieler ausge- wählt wurden. (Bei Brute-Force kommen ja auch andere Möglichkeiten vor.)


----------



## mihe7 (17. Nov 2022)

Womit hast Du denn genau ein Problem?


----------



## nichtkarim (17. Nov 2022)

mihe7 hat gesagt.:


> Womit hast Du denn genau ein Problem?


Ich verstehen nicht welche Schleifenart ich verwenden soll und wie ich die Boolean Werte setze, damit der am Ende die Spieler berechnet, die Ratsam sind


----------



## KonradN (17. Nov 2022)

Du hast eine Menge an Spielern und für das Spiel musst Du eine bestimmte Anzahl Spieler auswählen.

Damit hast Du eine Problematik ähnlich wie: Du hast eine Menge an Zahlen / Lottokugeln und ziehst davon eine bestimmte Anzahl.
(Um dann so z.B. alle Permutationen zu bekommen)

Bei der Problematik kommt jetzt nur hinzu, dass es für jede Permutation eine Prüfung gibt: erfüllt diese die Bedingungen? Wenn ja hast Du eine Lösung, wenn nein, dann geht es mit der nächsten "Ziehung" weiter.


----------



## mihe7 (17. Nov 2022)

nichtkarim hat gesagt.:


> Ich verstehen nicht welche Schleifenart ich verwenden soll und wie ich die Boolean Werte setze, damit der am Ende die Spieler berechnet, die Ratsam sind


Wenn Du nur mit booleans arbeiten willst, kannst Du eine do-while-Schleife verwenden.


```
boolean alSpielt = false;
do {
    alSpielt = !alSpielt;
    System.out.println(alSpielt);
} while (alSpielt);
```

Ablauf:
Zeile 1 initialisiert alSpielt mit false.
Zeile 3 toggelt alSpielt, zunächst also auf true
Zeile 4 gibt alSpielt aus (true)
Zeile 5 prüft, ob alSpielt. Dies ist der Fall also nächste Iteration
Zeile 3 toggelt alSpielt, jetzt auf false
Zeile 4 gibt alSpielt aus (false)
Zeile 5 prüft, ob alSpielt. Dies ist nicht der Fall -> Schleife terminiert.


----------



## nichtkarim (17. Nov 2022)

mihe7 hat gesagt.:


> Wenn Du nur mit booleans arbeiten willst, kannst Du eine do-while-Schleife verwenden.
> 
> 
> ```
> ...


Und wie genau funktioniert das, wenn bestimmt werden soll, wer zusammen spielt mit verschachtelten Schleifen?


----------



## mihe7 (17. Nov 2022)

nichtkarim hat gesagt.:


> Und wie genau funktioniert das, wenn bestimmt werden soll, wer zusammen spielt mit verschachtelten Schleifen?


Naja, indem Du die Schleifen eben verschachtelst. 

```
boolean alSpielt = false;
do {
    alSpielt = !alSpielt;

    boolean bertSpielt = false;
    do {
        bertSpielt = !bertSpielt;

        System.out.println("Al: " + alSpielt + ", Bert: " + bertSpielt);
    } while (bertSpielt);
} while (alSpielt);
```


----------



## Blender3D (17. Nov 2022)

nichtkarim hat gesagt.:


> Hallo,
> 
> es gibt eine Aufgabe bei der ich nun wirklich nicht weiterkomme. Ich verstehe an sich wie tiefe Schleifen funktionieren, bin bei der Aufgabe jedoch Ratlos.
> Kann mir da jemand helfen?


Eine alternative Lösung. 
1) Bilde die Potenzmenge. 
2) Nimm nur die mit 3 Elementen.
3) Nimm daraus nur die, die die Bedingungen erfüllen.


----------



## Blender3D (20. Nov 2022)

Blender3D hat gesagt.:


> Eine alternative Lösung.




```
import java.util.ArrayList;
import java.util.HashSet;

public class TestSpieler {
    private static String[] players = { "Al", "Cid", "Daniel", "Ernie", "Bert" };
    public final static int AL = 0;
    public final static int CID = 1;
    public final static int DANIEL = 2;
    public final static int ERNIE = 3;
    public final static int BERT = 4;
    public final static int TEAM_SIZE = 3;

    public static void main(String[] args) {
        ArrayList<HashSet<String>> teams = getTeams(players, TEAM_SIZE);
        for (HashSet<String> t : teams)
            printTeam(t);
    }

    public static ArrayList<HashSet<String>> getTeams(String[] players, int size) {
        ArrayList<HashSet<String>> allTeams = getPowerSet(players); // Potenzmenge
        ArrayList<HashSet<String>> teams = new ArrayList<>();
        for (HashSet<String> t : allTeams) { // nur Teams der Groesse size & Kriterien erfuellt
            if (t.size() == size && isPossibleTeam(t))
                teams.add(t);
        }
        return teams;
    }

    public static ArrayList<HashSet<String>> getPowerSet(String[] set) {
        ArrayList<HashSet<String>> result = new ArrayList<HashSet<String>>();
        subSets(set, new boolean[set.length], 0, result);
        return result;
    }

    public static boolean isPossibleTeam(HashSet<String> team) {
        if ((team.contains(players[DANIEL]) || team.contains(players[AL])) && !team.contains(players[CID]))
            return false;
        if (team.contains(players[BERT]) && team.contains(players[DANIEL]))
            return false;
        if (team.contains(players[BERT]) && !team.contains(players[ERNIE]))
            return false;
        if (!team.contains(players[BERT]) && team.contains(players[ERNIE]))
            return false;
        return true;
    }

    public static void printTeam(HashSet<String> current) {
        System.out.print("{ ");
        for (String p : current)
            System.out.print(p + " ");
        System.out.println("}");
    }

    private static void subSets(String[] set, boolean[] contained, int start, ArrayList<HashSet<String>> result) {
        if (start == contained.length) {
            HashSet<String> tmp = new HashSet<String>();
            for (int i = 0; i < contained.length; i++)
                if (contained[i])
                    tmp.add(set[i]);
            result.add(tmp);
        } else {
            subSets(set, contained, start + 1, result);
            contained[start] = true;
            subSets(set, contained, start + 1, result);
            contained[start] = false;
        }
    }
}
```


----------



## doofefragen123 (28. Nov 2022)

mihe7 hat gesagt.:


> Naja, indem Du die Schleifen eben verschachtelst.
> 
> ```
> boolean alSpielt = false;
> ...


Hallo, Ich habe dazu noch eine vielleicht doofe Frage, aber wie genau würde man in der Schleife jetzt festlegen, dass z.B. Al nur mit Cid spielen darf oder auch Daniel nur mit Cid und nicht mit Bert spielen kann.


----------



## mihe7 (28. Nov 2022)

doofefragen123 hat gesagt.:


> Hallo, Ich habe dazu noch eine vielleicht doofe Frage, aber wie genau würde man in der Schleife jetzt festlegen, dass z.B. Al nur mit Cid spielen darf oder auch Daniel nur mit Cid und nicht mit Bert spielen kann.


Mit if-Statements bzw. logischen Ausdrücken, z. B. Al und Cid müssen in ein Team: if (alSpielt && cidSpielt) { ... }


----------



## Blender3D (28. Nov 2022)

Im Code von Post #9  brauchst Du das lediglich hier eintragen.

```
public static boolean isPossibleTeam(HashSet<String> team) {
        if ((team.contains(players[DANIEL]) || team.contains(players[AL])) && !team.contains(players[CID]))
            return false;
        if (team.contains(players[BERT]) && team.contains(players[DANIEL]))
            return false;
        if (team.contains(players[BERT]) && !team.contains(players[ERNIE]))
            return false;
        if (!team.contains(players[BERT]) && team.contains(players[ERNIE]))
            return false;
        return true;
    }
```
https://www.java-forum.org/thema/brute-force-methode-mit-boolean.200060/#post-1332641


----------

