Galgenmännchen

felix92

Mitglied
Huhu liebe Community,
und zwar stehe ich gerade ziemlich auf dem Schlauch :eek:.
(wahrscheinlich mehr dumm als bewusst)
Wie bekomme ich es hin das in der ArrayList gelöst wirklich nur Elemente eingetragen werden die auch in ArrayList wort vorhanden sind ??

Code:
package galgen;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        System.out.println("GALGENMÄNNCHEN");
        System.out.println();
        System.out.println("Wort: _ _ _ _ ");
        System.out.println();

        List<Character> wort = new ArrayList<>();
        wort.add('J');
        wort.add('A');
        wort.add('V');
        wort.add('A');
        List<Character> gelöst = new ArrayList<>(4);
        gelöst.add(' ');

        lösen(gelöst, wort);

    }

    public static void lösen(List<Character> gelöst, List<Character> wort) {
        @SuppressWarnings("resource")
        Scanner scanner = new Scanner(System.in);
        int i = 0;

        while (gelöst != wort) {

            char eingabe = (char) scanner.next().charAt(0);
            if (eingabe == 'J') {
                gelöst.add(0, 'J');
                gelöst.set(0, 'J');
                System.out.println(gelöst.toString());

            } else if (eingabe == 'A') {
                gelöst.add(1, 'A');
                gelöst.set(1, 'A');
                gelöst.add(3, 'A');
                gelöst.set(3, 'A');
                System.out.println(gelöst.toString());

            } else if (eingabe == 'V') {
                gelöst.add(2, 'V');
                gelöst.set(2, 'V');
                System.out.println(gelöst.toString());

            } else if (gelöst.equals(wort) == true) {
                System.out.println(gelöst.toString());
            } else {
                i = i + 1;
                System.out.println();
                rip.galgen(i, eingabe);
                System.out.println();
                if (i == 7) {
                    System.exit(0);
                }

            }

        }
    }

    @Override
    public String toString() {
        return "Main [getClass()=" + getClass() + ", hashCode()=" + hashCode() + ", toString()=" + super.toString()
                + "]";
    }

}

Code:
package galgen;

public class rip {

    public static void galgen(int fehler, char eingabe) {
        switch (fehler) {

        case 1:
            System.out.println("--------------");
            System.out.println("");
            System.out.println(" //\\  ");
            System.out.println("--------------");

            break;
        case 2:
            System.out.println("--------------");
            System.out.println("");
            System.out.println("  |");
            System.out.println(" //\\  ");
            System.out.println("--------------");

            break;

        case 3:
            System.out.println("--------------");
            System.out.println("");
            System.out.println("  |");
            System.out.println("  |");
            System.out.println(" //\\  ");
            System.out.println("--------------");
            break;

        case 4:
            System.out.println("--------------");
            System.out.println("");
            System.out.println("  |");
            System.out.println("  | ");
            System.out.println("  |");
            System.out.println(" //\\  ");
            System.out.println("--------------");
            break;

        case 5:
            System.out.println("--------------");
            System.out.println("");
            System.out.println("  |");
            System.out.println("  |");
            System.out.println("  |");
            System.out.println("  |");
            System.out.println(" //\\  ");
            System.out.println("--------------");
            break;

        case 6:
            System.out.println("--------------");
            System.out.println("   ___");
            System.out.println("  |   ");
            System.out.println("  |   ");
            System.out.println("  |   ");
            System.out.println("  |   ");
            System.out.println(" //\\  ");
            System.out.println("--------------");
            break;

        case 7:
            System.out.println("--------------");
            System.out.println("   ____  ");
            System.out.println("  |    | ");
            System.out.println("  |    O ");
            System.out.println("  |   /|\\");
            System.out.println("  |   / \\");
            System.out.println(" //\\  ");
            System.out.println("--------------");
            System.out.println("Sry das wahr wohl nichts !!");

            break;

        default:
            System.out.println(eingabe + " ist falsch!");
            break;
        }

    }
}

Vielen Dank für eure Hilfe ;)
 

felix92

Mitglied
Danke krgewb,
allerdings löst das nicht so recht mein Problem :(
Buchstaben die doppelt vorkommen werden jetzt nur 1x in die neue ArrayList geschrieben und ich weiß nicht warum, aber mit dieser Änderung schmiert mir das Programm ab ohne Fehlermeldung(Buchstaben können weiter eingegeben werden allerdings ohne "Wirkung" davor nicht).
Problem ist ich möchte es unbedingt mit einer ArrayList lösen andere Wege gibt es zu genüge das weiß ich selbst aber hier hänge ich gerade irgendwie fest :/
Problematik:
Es dürfen nur eingelesene Chars in das neue Array(an die korrekte Position(index)) geschrieben werden die auch im AusgangsArray vorhanden sind(inklusive doppelt vorhandene Buchstaben).
Alles andere sollte die else Bedingung auslösen.
MfG Felix
 

mihe7

Top Contributor
allerdings löst das nicht so recht mein Problem
Das liegt daran, dass Du Dein Problem nicht richtig beschrieben hast. Deine Frage hat @krgewb korrekt beantwortet :)

Zurück zum Thema. Du hast ein Wort w und eine gleich lange Teillösung l. Überleg doch einfach mal, was für einen Buchstaben b passieren muss
Code:
falls b in w enthalten
    setze(b, l, w)
sonst
    fehler++
Die erste Zeile sollte Dir bekannt vorkommen... setze(b, l, w) setzt den Buchstaben b in l an die Positionen, an denen b in w vorkommt. Idee: man geht einfach alle Positionen i von w durch, prüft ob der jeweilige Buchstabe w[i] mit b übereinstimmt und ersetzt ggf. l[i] mit b. Algorithmus dafür:
Code:
i := 0
so lange i < laenge(w)
    falls w[i] == b
        l[i] := b
    i++
Nach Java darfst Du selbst übersetzen ;)
 

felix92

Mitglied
Huhu,
ich nochmal :D
Und zwar habe ich jetzt das Problem das wenn in einem Ausgangswort mehrere gleiche Buchstaben vorkommen diese
1. nur einmal ins Zielarray eingefügt werden und
2. wenn Sie in der falschen Reihenfolge eingegeben werden wirft er mir java.lang.IndexOutOfBoundsException ...
gibt es eine Möglichkeit der ArrayList gelöst vorab eine feste Indexreihenfolge zuzuordnen oder denke ich da zu umständlich ? :/
für Lösungsvorschläge wäre ich dankbar :)

MfG Felix

Code:
package galgen;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        System.out.println("GALGENMÄNNCHEN");
        System.out.println();
        System.out.println("Wort: _ _ _ _ ");
        System.out.println();

        List<Character> wort = new ArrayList<Character>();
        wort.add(0, 'J');
        wort.add(1, 'A');
        wort.add(2, 'V');
        wort.add(3, 'A');
        List<Character> gelöst = new ArrayList<Character>(4);
        lösen(gelöst, wort);

    }

    public static void lösen(List<Character> gelöst, List<Character> wort) {
        @SuppressWarnings("resource")
        Scanner scanner = new Scanner(System.in);
        int i = 0;
        int max = 7;

        while (gelöst.size() != wort.size()) {

            char eingabe = scanner.next().charAt(0);
            if (wort.contains(eingabe)) {
                for (int j = 0; j < wort.size(); j++) { // ToDo: Buchstaben die öfters vorkommen auf einmal einfügen
                                                        // java.lang.IndexOutOfBoundsException
                    if (wort.get(j) == eingabe) {
                        gelöst.add(j, eingabe);
                        System.out.println(gelöst.toString());
                        lösen(gelöst, wort);

                        if (wort.size() == gelöst.size()) {
                            System.out.println("Herzlichen Glückwunsch du hast es gelöst !!");
                            System.exit(0);
                        }
                    }

                }
            }

            else {
                i = i + 1;
                System.out.println();
                rip.galgen(i, eingabe);
                if (i == max) {
                    System.exit(0);
                }
            }

        }

    }

    @Override
    public String toString() {
        return "Main [getClass()=" + getClass() + ", hashCode()=" + hashCode() + ", toString()=" + super.toString()
                + "]";
    }

}
 

mihe7

Top Contributor
Ein paar Java-Grundlagen würden nicht schaden...

List<Character> gelöst = new ArrayList<Character>(4);
Die 4 bedeutet nicht, dass die ArrayList 4 Elemente enthalten würde, sondern dass sie initial eine Kapazität für 4 Elemente hat. Übrigens: vermeide Umlaute in Bezeichnern, besser geloest statt gelöst.

Du müsstest also erst einmal vier Elemente hinzufügen:
for (int i = 0; i < 4; i++) gelöst.add('_');

Damit wir den Spaß gleich richtig machen, sollten wir das Problem richtig formulieren: wir brauchen so viele Unterstriche, wie wort Elemente besitzt...
Java:
for (int i = 0, n = wort.size(); i < n; i++) {
    gelöst.add('_');
}

Jetzt gilt natürlich gelöst.size() == wort.size() -> da musst Du Dir was überlegen...

Dafür wird zu gelöst nichts mehr hinzugefügt, sondern die Elemente werden einfach gesetzt: gelöst.set(j, eingabe).
 

felix92

Mitglied
Huhu mihe7,
erstmal danke für deine Antwort.
Die Bedeutung der 4 ist mir schon bewusst. :)
So hatte ich es auch schon probiert ...allerdings sehe ich gerade im Nachhinein das ich vergessen hatte add durch set zu tauschen :)
Danke ich probiers nochmal
 

felix92

Mitglied
Ja die "Platzhalter" hatte ich dort auch...
Mal so ne Frage nebenbei gibt es eine Möglichkeit eine Arraylist schon beim erstellen voll zu belegen mit "irgendetwas" ohne sie selbst befüllen zu müssen ?
 

mihe7

Top Contributor
Solche Fragen beantwortet die API-Doku:
https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html

-> Ja, mit einer Collection

Q: gibt es eine Möglichkeit eine Collection mit irgendwas zu erstellen?

A: Ja, z. B. mit der Methode asList aus java.util.Arrays.

Q: wie sieht das dann aus?

A: Beispiel:
Java:
List<String> zeichenketten = new ArrayList<>(Arrays.asList("String 1", "String 2", ...));
// oder
String[] daten = new String[]{"String 1", "String 2", ....};
List<String> zeichenketten = new ArrayList<>(Arrays.asList(daten));

Q: wenn Arrays.asList eine List liefert, wozu dann noch eine neue ArrayList verwenden?

Ob das notwendig ist, kommt darauf den Fall an. Die von Arrays.asList zurückgegebene Liste ist nicht modifizierbar. Muss man aus der Liste nur lesen, kann man also auch einfach
Java:
List<String> zeichenketten = Arrays.asList("String 1", "String 2", ...);
schreiben.

Daneben gibt es z. B. auch die Möglichkeit, mit Streams (java.util.stream.Stream) zu arbeiten, das bietet sich vor allem an, wenn man die Daten vorab noch verarbeiten will, z. B:

Java:
List<String> zeichenketten = Stream.of("Hans", "Heiner", "Maria", "Marion").
    .filter(s -> s.startsWith("M"))
    .collect(Collectors.toList());
liefert dann eine unmodifizierbare Liste von Zeichenketten, die mit M beginnen.
 

felix92

Mitglied
@krgewb nein derzeit noch Eclipse ... hatte aber vor mich demnächst mal mit IntelliJ vertraut zu machen.
So zum Abschluss:
Code:
public class Main {

    public static void main(String[] args) {
        int f = 0; // Anzahl Fehler
        System.out.println("\n | Galgenmännchen - Spiel |");
        System.out.println(" -------------------------- \n");

        List<Character> wort = new ArrayList<Character>();
        wort.add(0, 'J');
        wort.add(1, 'A');
        wort.add(2, 'V');
        wort.add(3, 'A');
        wort.add(4, 'I');
        wort.add(5, 'N');
        wort.add(6, 'S');
        wort.add(7, 'E');
        wort.add(8, 'L');

        System.out.println("Länge des Wortes: " + wort.size());
        System.out.println("gesuchtes Wort:");
        System.out.println();
        for (int i = 0; i < wort.size(); i++) {
            System.out.print(" _ ");
        }
        System.out.println("\n");

        List<Character> geloest = new ArrayList<Character>();
        for (int i = 0; i < wort.size(); i++) {
            geloest.add('_');
        }
        lösen(f, geloest, wort);

    }

    public static void lösen(int f, List<Character> geloest, List<Character> wort) {
        @SuppressWarnings("resource")
        Scanner scanner = new Scanner(System.in);
        int max = 8; // maximale Versuche
        boolean fertig = false;
        boolean erledigt = false;

        while (fertig == false) {

            char eingabe = scanner.next().charAt(0); // nur Großbuchstaben
            if (!Character.isUpperCase(eingabe)) {
                System.out.println("Bitte nur Großbuchstaben eingeben ! ;) \nnochmal: ");
                lösen(f, geloest, wort);
            }
            if (!wort.contains(eingabe)) { // Fehler -> case+1
                System.out.println("\nEingabe : " + eingabe + " ist leider falsch :( ");
                f = f + 1;
                System.out.println();
                rip.galgen(f, eingabe);
                if (f == max) {
                    System.exit(0);
                }
            }

            if (wort.contains(eingabe)) {// Vergleich mit Ausgangsliste
                while (wort.contains(eingabe) && erledigt == false && !geloest.contains(eingabe)) {
                    for (int j = 0; j < wort.size(); j++) {
                        if (wort.get(j) == eingabe) {
                            geloest.set(j, eingabe);
                            System.out.println("\nEingabe : " + eingabe + " ist richtig!");
                            System.out.println("\n" + geloest.toString()); /*
                                                                             * for (Character character : geloest) {
                                                                             * System.out.print( "  " + character);
                                                                             */
                        }

                    }

                    if (geloest.containsAll(wort)) { // wenn gelöst
                        System.out.println("Herzlichen Glückwunsch du hast es gelöst !!");
                        System.exit(0);

                    }
                }
                erledigt = true;
                lösen(f, geloest, wort); // von vorne solange nicht gelöst
            }
        }

    }

    @Override
    public String toString() {
        return "Main [getClass()=" + getClass() + ", hashCode()=" + hashCode() + ", toString()=" + super.toString()
                + "]";
    }

}

Code:
public class rip {

    public static void galgen(int fehler, char eingabe) {
        switch (fehler) {

        case 1:
            System.out.println("--------------");
            System.out.println("");
            System.out.println(" //\\  ");
            System.out.println("--------------");

            break;
        case 2:
            System.out.println("--------------");
            System.out.println("");
            System.out.println("  |");
            System.out.println(" //\\  ");
            System.out.println("--------------");

            break;

        case 3:
            System.out.println("--------------");
            System.out.println("");
            System.out.println("  |");
            System.out.println("  |");
            System.out.println(" //\\  ");
            System.out.println("--------------");
            break;

        case 4:
            System.out.println("--------------");
            System.out.println("");
            System.out.println("  |");
            System.out.println("  | ");
            System.out.println("  |");
            System.out.println(" //\\  ");
            System.out.println("--------------");
            break;

        case 5:
            System.out.println("--------------");
            System.out.println("");
            System.out.println("  |");
            System.out.println("  |");
            System.out.println("  |");
            System.out.println("  |");
            System.out.println(" //\\  ");
            System.out.println("--------------");
            break;

        case 6:
            System.out.println("--------------");
            System.out.println("   ___");
            System.out.println("  |   ");
            System.out.println("  |   ");
            System.out.println("  |   ");
            System.out.println("  |   ");
            System.out.println(" //\\  ");
            System.out.println("--------------");
            break;
        case 7:
            System.out.println("--------------");
            System.out.println("   ____");
            System.out.println("  |   ");
            System.out.println("  |   ");
            System.out.println("  |   ");
            System.out.println("  |   ");
            System.out.println(" //\\  ");
            System.out.println("--------------");
            break;   

        case 8:
            System.out.println("--------------");
            System.out.println("   ____  ");
            System.out.println("  |    | ");
            System.out.println("  |    O ");
            System.out.println("  |   /|\\");
            System.out.println("  |   / \\");
            System.out.println(" //\\  ");
            System.out.println("--------------");
            System.out.println("Sry das wahr wohl nichts !!");

            break;

        default:
           
            break;
        }

    }
}

Danke für eure Hilfe :)
Das Grundgerüst steht werde da mal noch ein wenig herumexperimentieren :)
 

felix92

Mitglied
Huhu,
ich hätte da nochmal ne Frage !
Und zwar möchte ich aus einer .txt Datei eine zufällige Zeile auswählen.
Ich dachte mir so ich zähle alle Wörter durch lasse mir daraus eine random Zahl erstellen und greife damit auf die zufällige Zeile zu allerdings fuktioniert das nicht so recht ^^
Hintergrund dazu ist das die random gewählte Zeile eingelesen wird , der String in chars zerlegt wird und in eine ArrayList wandert.
Ich hatte es auch schon mit
Code:
LineNumberReader
probiert allerdings ging dort meine Idee mit der random Zeile nicht so auf :confused:
Vlt. hat ja jmd nen Tipp wie ich das anstellen könnte :)

Danke
Derzeitiger Code:

Code:
        List<Character> wort = new ArrayList<Character>(); // StartArray

        int f = 0; // Anzahl Fehler

        System.out.println("\n | Galgenmännchen - Spiel |");
        System.out.println(" -------------------------- \n");

        File file = new File("woerter.txt");

        BufferedReader br = null;

        try {

            int count = 1;

            Random random = new Random();

            FileReader reader = new FileReader(file);
            br = new BufferedReader(reader);

            String line = br.readLine(); // Zeile lesen und chars in ArrayList
            for (char c : line.toCharArray()) {
                wort.add(c);
            }

            while ((line = br.readLine()) != null) { // zählen der Wörter
                count++;
                System.out.println("Zähler" + count);

            }
            int zufall = random.nextInt(count);
            System.out.println("Zahl " + zufall);

            System.out.println(wort.toString());

        } catch (FileNotFoundException e) {
            System.out.println("Datei nicht gefunden : " + file.toString());
        } catch (IOException e) {
            System.out.println("Datei nicht lesbar : " + file.toString());
        } finally {
            try {
                br.close();
            } catch (IOException e) {
                System.out.println("Datei kann nicht geschlossen werden : " + file.toString());
            } catch (NullPointerException e2) {
            }
 
Zuletzt bearbeitet:

mihe7

Top Contributor
Mal zwei Varianten für den Einstieg:
1. die einfache: merk Dir die Zeilen in einer Liste und such Dir aus der Liste ein zufälliges Element aus.
2. die etwas schnellere und weniger RAM-hungrige: beginne die Datei mit der Anzahl der Wörter. Die liest Du zuerst ein und kannst Deine Zufallszahl x wählen. Dann "überliest" Du einfach x-1 Zeilen, bevor Du das gesuchte Wort einliest
 

felix92

Mitglied
@mihe7 Danke ich habe es jetzt mit 2 Readern gelöst :)
Für Verbesserungsvorschläge wäre ich sehr dankbar !
PS: Die vielen übertriebenen Kommentare bitte nicht bemängeln musste ich so ausführlich machen :confused:

Main:
Code:
public class Main {

    public static void main(String[] args) {
        int f = 0; // Anzahl Fehler
        List<Character> wort = new ArrayList<Character>(); // StartArray
        List<Character> geloest = new ArrayList<Character>(); // ZielArray

        System.out.println("\n | Galgenmännchen - Spiel |");
        System.out.println(" -------------------------- \n");

        System.out.println("Länge des Wortes: " + wort.size());
        System.out.println("gesuchtes Wort:");
        System.out.println("Bitte verwende nur Großbuchstaben und bestätige mit Enter !");
        System.out.println("");

        Zufallswort.zufallsWort(wort); // Zufallswortmethode
        for (int i = 0; i < wort.size(); i++) {
            System.out.print(" _ ");
        }
        System.out.println("\n");

        for (int i = 0; i < wort.size(); i++) { // belegen zum überschreiben
            geloest.add('_');
        }
        Lösen.lösen(f, geloest, wort); // Spielstart

    }

}

Zufallswort:
Code:
public class Zufallswort {

    public static void zufallsWort(List<Character> wort) {

        File file = new File("woerter.txt");  // Datei
        BufferedReader br = null;
        BufferedReader br2 = null;

        try {

            int count = 0;
            @SuppressWarnings("unused")
            String line;
            String zufälligeLine;

            Random random = new Random();
            FileReader reader = new FileReader(file); // 2 Reader 1ste zum auszählen der Länge 2te zum adden des
                                                        // Zufallswortes
            FileReader reader2 = new FileReader(file);
            br = new BufferedReader(reader);
            br2 = new BufferedReader(reader2);

            while ((line = br.readLine()) != null) { // zählen der Wörter
                count++;
            }
            br.close(); // close da count erledigt

            int zufall = random.nextInt(count); // Zufalls int aus Anzahl der Wörter
            zufall = zufall + 1;

            for (int i = 0; i < count + 2; i++) { // Zufallswort in Array als chars adden
                zufälligeLine = br2.readLine();
                if (i == zufall) {
                    for (char c : zufälligeLine.toCharArray()) {
                        wort.add(c);
                    }
                    br2.close(); // close da Wort in Array
                    break;
                }

            }

        } catch (FileNotFoundException e) {
            System.out.println("Datei nicht gefunden : " + file.toString());
        } catch (IOException e) {
            System.out.println("Datei nicht lesbar : " + file.toString());
        }

    }

}

Code:
public class Lösen {

    public static void lösen(int f, List<Character> geloest, List<Character> wort) {
        @SuppressWarnings("resource")
        Scanner scanner = new Scanner(System.in);
        int max = 8; // maximale Versuche
        boolean fertig = false;
        long timeStart = 0;
        long timeEnd = 0;

        timeStart = System.currentTimeMillis();
        while (fertig == false) {

            char eingabe = scanner.next().charAt(0);

            if (!Character.isUpperCase(eingabe)) { // nur Großbuchstaben
                System.out.println("Bitte nur Großbuchstaben eingeben ! ;) \nnochmal: ");
                lösen(f, geloest, wort);
            }
            if (geloest.contains(eingabe)) { // falls Buchstabe schon verwendet wurde
                System.out.println("\nDieser Buchstabe wurde schon benutzt !");
                lösen(f, geloest, wort);
            }
            if (!wort.contains(eingabe)) { // Buchstabe nicht im Ausgangswort -> Fehler -> case+1
                System.out.println("\nEingabe : " + eingabe + " ist leider falsch :( ");
                f = f + 1;
                System.out.println();
                Rip.galgen(f, eingabe);
                if (f == max) {
                    System.exit(0);
                }
            }

            if (wort.contains(eingabe)) {// Vergleich mit Ausgangsliste
                int highscore;
                while (wort.contains(eingabe) && !geloest.contains(eingabe)) {
                    for (int j = 0; j < wort.size(); j++) {
                        if (wort.get(j) == eingabe) { // Buchstabe an korrekte Position setzen
                            geloest.set(j, eingabe);
                            System.out.println("\nEingabe : " + eingabe + " ist richtig!");
                            System.out.println("\n" + geloest.toString());
                        }

                    }

                    if (geloest.containsAll(wort)) { // wenn gelöst + benötigte Zeit + Score
                        timeEnd = System.currentTimeMillis();
                        System.out.println("\nHerzlichen Glückwunsch du hast es gelöst !!");
                        long ergebniss = timeEnd - timeStart;
                        if (ergebniss < 2000) {
                            highscore = (int) (60 * ergebniss);
                            System.out.println();
                        } else if (ergebniss < 5000) {
                            highscore = (int) (25 * ergebniss);
                            System.out.println();
                        } else {
                            highscore = (int) (5 * ergebniss);
                            System.out.println();
                        }
                        System.out.println("Du hast " + ergebniss + " Millisekunden benötigt und dein Punktestand ist: "
                                + highscore + " !");
                        System.exit(0);

                    }
                }
                lösen(f, geloest, wort); // von vorne solange nicht gelöst
            }
        }

    }

    @Override
    public String toString() {
        return "Main [getClass()=" + getClass() + ", hashCode()=" + hashCode() + ", toString()=" + super.toString()
                + "]";
    }

}

Rip:
Code:
public class Rip {

    public static void galgen(int fehler, char eingabe) {
        switch (fehler) {

        case 1:
            System.out.println("--------------");
            System.out.println("");
            System.out.println(" //\\  ");
            System.out.println("--------------");

            break;
        case 2:
            System.out.println("--------------");
            System.out.println("");
            System.out.println("  |");
            System.out.println(" //\\  ");
            System.out.println("--------------");

            break;

        case 3:
            System.out.println("--------------");
            System.out.println("");
            System.out.println("  |");
            System.out.println("  |");
            System.out.println(" //\\  ");
            System.out.println("--------------");
            break;

        case 4:
            System.out.println("--------------");
            System.out.println("");
            System.out.println("  |");
            System.out.println("  | ");
            System.out.println("  |");
            System.out.println(" //\\  ");
            System.out.println("--------------");
            break;

        case 5:
            System.out.println("--------------");
            System.out.println("");
            System.out.println("  |");
            System.out.println("  |");
            System.out.println("  |");
            System.out.println("  |");
            System.out.println(" //\\  ");
            System.out.println("--------------");
            break;

        case 6:
            System.out.println("--------------");
            System.out.println("   ___");
            System.out.println("  |   ");
            System.out.println("  |   ");
            System.out.println("  |   ");
            System.out.println("  |   ");
            System.out.println(" //\\  ");
            System.out.println("--------------");
            break;
        case 7:
            System.out.println("--------------");
            System.out.println("   ____");
            System.out.println("  |   ");
            System.out.println("  |   ");
            System.out.println("  |   ");
            System.out.println("  |   ");
            System.out.println(" //\\  ");
            System.out.println("--------------");
            break;

        case 8:
            System.out.println("--------------");
            System.out.println("   ____  ");
            System.out.println("  |    | ");
            System.out.println("  |    O ");
            System.out.println("  |   /|\\");
            System.out.println("  |   / \\");
            System.out.println(" //\\  ");
            System.out.println("--------------");
            System.out.println("Sry das wahr wohl nichts !!");

            break;

        default:

            break;
        }

    }
}

woerter.txt:
Code:
DASWARECHTHARTZULOESENVERDAMMTMAN
LOW
NETZWERK
UDEMY
JAVAISTEINEINSEL
JAVAFX
POLYMORPHIE
BIT
DECODER
FESTPLATTE
HOTSPOT
INTRANET
KRYPTOGRAPHIE
STEGANOGRAPHIE
OBJEKTORIENTIERUNG
COLLECTIONS
COMPILER
INTERPRETER
ANWENDUNGSENTWICKLUNG
PROGRAMMIERUNG
 

felix92

Mitglied
Ah ok danke schau ich mir mal an !
Ich habe gerade auch noch angepasst das doppelte Eingaben egal ob richtig oder falsch abgefangen werden.
Code:
Set<Character> schonVerwendet = new HashSet<Character>(); // alle eingegebenen Buchstaben
Code:
if ((schonVerwendet.contains(eingabe) && !wort.contains(eingabe)) || (schonVerwendet.contains(eingabe) && geloest.contains(eingabe))) { // wenn Buchstabe schon verwendet wurde
                System.out.println("\nDieser Buchstabe wurde schon verwendet !");
                System.out.println("bisherige Buchstaben : " + schonVerwendet.toString());
                lösen(f, geloest, wort, schonVerwendet);
            }

Ansonsten passt das so ? :)
MfG Felix
 

mihe7

Top Contributor
Ansonsten passt das so ?
Wenn es Dir passt, und alles so funktioniert, wie es soll, was soll dann nicht passen? Mit Objektorientierung hat der Code halt nichts zu tun, aber das kommt darauf an, was das Ziel ist.

Noch was. Hier ist ein Beispiel für einen "schlechten Kommentar":
Code:
if ((schonVerwendet.contains(eingabe) && !wort.contains(eingabe)) || (schonVerwendet.contains(eingabe) && geloest.contains(eingabe))) { // wenn Buchstabe schon verwendet wurde
Warum? Weil er beschreibt, WAS gemacht wird. Für das Was hat man aber schon eine Beschreibung: den Code. Wird ein Kommentar benötigt, um zu beschreiben, was der Code macht, dann ist der Code nicht gut (letztlich ist es also ein Beispiel für schlechten Code und nicht für einen schlechten Kommentar, darum habe ich das oben in Anführungszeichen gesetzt).

Wie lässt sich so etwas beheben? Ganz einfach: verwende Code statt Kommentare.
Code:
if (bereitsVerwendet(eingabe)) {
...
Der Aufruf entspricht jetzt fast wörtlich dem Kommentar :) So einfach sieht das allerdings nur aus, wenn Du Objekte verwendest, ansonsten müsstest Du wort, schonVerwendet und geloest zusätzlich als Parameter übergeben.
 

felix92

Mitglied
Ja da gebe ich dir Recht normalerweise mache ich Kommentare immer nur oberhalb einer Klasse falls benötigt und über Methoden aber hier soll das so "übertrieben" sein :)
Auch das es nicht objektorientiert ist, ist so gedacht.
Ich danke dir aufjedenfall für deine Hilfe und wünsche dir noch einen schönen Abend :)
 

Neue Themen


Oben