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 :)
 

Anfaengerin

Aktives Mitglied
Hallo, ich bin inzwischen auch bei dem Thema. Mache es nach Anleitung, der Software-Developer will, dass wir erst eine Liste von Wörtern importieren, aber daran scheitert es schon bei mir.

Ich kopier mal den Code rein:

Java:
import java.util.Scanner;

public class Hangman {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        

Scanner scanner = new scanner(new File("C:/Users/49152/Desktop/Woerter.txt"));

while (Scanner.hasnext()) {
    
System.out.println(Scanner.nextLine);
    
}
}}
 

Anhänge

  • Eclipse04062024.PNG
    Eclipse04062024.PNG
    81,5 KB · Aufrufe: 0

Anfaengerin

Aktives Mitglied
Oh ok, jetzt zeigt er diese Fehlermeldung schon mal nicht mehr an, danke.

Jetzt zeigt er mir eine Fehlermeldung bei "nextLine".
 

Anhänge

  • Eclipse04062024-2.PNG
    Eclipse04062024-2.PNG
    79,6 KB · Aufrufe: 0
Zuletzt bearbeitet:

KonradN

Super-Moderator
Mitarbeiter
Der Typ / Klasse heisst "Scanner". Die Variable, die Du deklariert heisst, heisst "scanner".

Bei "new Scanner(...)" hast Du gesagt, dass Du eine neue Instanz der Klasse Scanner anlegen willst.
Bei "scanner.nextLine()" willst Du die Methode nextLine auf der erzeugten Scanner Instanz aufrufen.

Daher: dort muss Scanner klein geschrieben werden.

Edit: Nicht erwähnt: das n von nextLine muss klein geschrieben werden. Was evtl. hilft sind die style guides in Java:
  • Klassen starten mit einem großen Buchstaben
  • Variablen und Methoden starten mit einem kleinen Buchstaben
 

Anfaengerin

Aktives Mitglied
Dankeschön für die Erklärung.

Jetzt hab ich das geändert, aber danach war es rot unterkringelt, sodass ich doch wieder die Großschreibung genommen habe und er gibt mir die Begriffe aus.

Java:
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.io.File;

public class Hangman {

    public static void main(String[] args) throws FileNotFoundException {
        // TODO Auto-generated method stub
        

Scanner Scanner = new Scanner(new File("C:/Users/49152/Desktop/Woerter.txt"));

while (Scanner.hasNext()) {
    
System.out.println(Scanner.nextLine());
    
}
}}
 

Anhänge

  • Eclipse04062024-4.PNG
    Eclipse04062024-4.PNG
    78 KB · Aufrufe: 0

Robert Zenz

Top Contributor
Nein, du musst unterscheiden zwischen Klassenname und Variablenname.

Java:
Klassenname variablenname = new Klassenname();

variablenname.funktionsaufruf();

Scanner ist der Klassenname, der muss am Anfang grosz geschrieben werden. scanner hingegen waere dein Variablenname, welchen du frei waehlen kannst so nebenebei erwaehnt, und die schreibt man traditionell am Anfang klein. Also korrekter waere:

Java:
Scanner scanner = new Scanner(new File("C:/Users/49152/Desktop/Woerter.txt"));

while (scanner.hasNext()) {
    System.out.println(scanner.nextLine());
}

Oder alternativ um noch den Punkt der Freiwaehlbarkeit zu unterstreichen:


Java:
Scanner dieVariableVonDeinerScannerInstanz = new Scanner(new File("C:/Users/49152/Desktop/Woerter.txt"));

while (dieVariableVonDeinerScannerInstanz.hasNext()) {
    System.out.println(dieVariableVonDeinerScannerInstanz.nextLine());
}

Wenn du die Variable Scanner (mit groszem Anfang) nennst, dann "ueberdeckst" du die Klasse Scanner...ehrlich gesagt weisz ich gar nicht was dann genau passiert, aber zumindest wirst du nicht mehr auf statische Methoden auf der Klasse zugreifen koennen weil Scanner eben eine Instanz ist.
 

Anfaengerin

Aktives Mitglied
Danke für die ausführliche Erklärung. Tut mir leid, wenn ich beratungsresistent scheine, aber da war halt der rote Kringel. Ich nehme mir eure Erläuterungen aber zu Herzen. Ich versuchs direkt nochmal, wenn ich wieder zu Hause bin.
 

Anfaengerin

Aktives Mitglied
Ich hab es jetzt. Ich hatte vergessen, die Variable oben bei "Scanner scanner" auch kleinzuschreiben, deswegen bei den unteren beiden die rote Unterkringelung.

Ich hab jetzt

Java:
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.io.File;

public class Hangman {

    public static void main(String[] args) throws FileNotFoundException {
        // TODO Auto-generated method stub
        

Scanner scanner = new Scanner(new File("C:/Users/49152/Desktop/Woerter.txt"));

while (scanner.hasNext()) {
    
System.out.println(scanner.nextLine());
    
}
}}

Danke für alles!
 

Anhänge

  • Eclipse04062024-5.PNG
    Eclipse04062024-5.PNG
    76,4 KB · Aufrufe: 0

Anfaengerin

Aktives Mitglied
Jetzt häng ich wieder. Wegen einer unterkringelten geschweiften Klammer, in Zeile 60. Ich hab schon versucht, eine Klammer hinzuzufügen und eine Klammer wegzulöschen, aber der rote Kringel bleibt.

Java:
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.io.File;

public class Hangman {

    public static void main(String[] args) throws FileNotFoundException {
        // TODO Auto-generated method stub
        

Scanner scanner = new Scanner(new File("C:/Users/49152/Desktop/Woerter.txt"));

Scanner keyboard = new Scanner (System.in);

List<String> words = new ArrayList<>();

while (scanner.hasNext()) {
    
words.add(scanner.nextLine());}

Random rand = new Random();

String word = words.get(rand.nextInt(words.size()));

System.out.println(word);
    
List<Character> playerGuesses = new ArrayList<>();




int wrongCount = 0;
while (true) {
    if (wrongCount >= 1) {System.out.println("  O");}
    if (wrongCount >= 2) {System.out.print("\\ ");
    if (wrongCount >= 3) {System.out.println(" /");} else {System.out.println("");}
    if (wrongCount >= 4) {System.out.println("  |");}
    if (wrongCount >= 5) {System.out.print("/");
    if (wrongCount >= 6) {System.out.println(" \\");} else {System.out.println("");}
    
    System.out.println("-------");
    System.out.println("|      |");
    
    printWordState(word, playerGuesses);
    
    if (!getPlayerGuess(keyboard, word, playerGuesses)) {wrongCount++;};


if (printWordState(word, playerGuesses))

{System.out.println("Du hast gewonnen!"); break;

}
System.out.println("Bitte hier das ganze Wort lösen.");
if (keyboard.nextLine().equals(word)) {System.out.println("Du hast gewonnen!"); break;}

else {System.out.println("Falsch. Versuch es noch einmal.");}
    

    
}
    

    private static boolean getPlayerGuess(Scanner keyboard, String word, List<Character> playerGuesses) {
        System.out.println("Bitte gib einen Buchstaben ein.");
        
        String letterGuess = keyboard.nextLine();
        playerGuesses.add(letterGuess.charAt(0));
        
        return word.contains(letterGuess);
        
        
    }

    private static boolean printWordState(String word, List<Character> playerGuesses) {
        int correctCount = 0;
        
        for (int i = 0; i < word.length(); i++) {
            
            if (playerGuesses.contains(word.charAt(i))) {System.out.print(word.charAt(i));
            correctCount++;
            }
            else {System.out.print("-");}
        
        };
        
        System.out.println();
    
    return(word.length() == correctCount);
    }

}
 

Anhänge

  • 06062024.PNG
    06062024.PNG
    104,8 KB · Aufrufe: 0

KonradN

Super-Moderator
Mitarbeiter
Dein Problem ist, dass Du keine saubere Einrückung hast. Eclipse kann Deinen Code eigenständig formatieren und das solltest Du nutzen!
(Die Tastenkombination unter Linux und Windows wäre Shift-Control F)

Zusätzlich: Mach nur ein Befehl pro Zeile! Dann siehst Du auch, wo was anfängt bzw. endet, d.h.
  • geschweifte Klammer auf ist immer am Zeilenende
  • geschweifte Klammer zu ist immer in einer neuen Zeile
  • Ein Statement hat immer seine eigene Zeile
Deinen aktuellen Code einmal formatiert wäre dann:
Java:
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.io.File;

public class Hangman {

    public static void main(String[] args) throws FileNotFoundException {
        // TODO Auto-generated method stub


        Scanner scanner = new Scanner(new File("C:/Users/49152/Desktop/Woerter.txt"));

        Scanner keyboard = new Scanner(System.in);

        List<String> words = new ArrayList<>();

        while (scanner.hasNext()) {

            words.add(scanner.nextLine());
        }

        Random rand = new Random();

        String word = words.get(rand.nextInt(words.size()));

        System.out.println(word);

        List<Character> playerGuesses = new ArrayList<>();


        int wrongCount = 0;
        while (true) {
            if (wrongCount >= 1) {
                System.out.println("  O");
            }
            if (wrongCount >= 2) {
                System.out.print("\\ ");
                if (wrongCount >= 3) {
                    System.out.println(" /");
                } else {
                    System.out.println("");
                }
                if (wrongCount >= 4) {
                    System.out.println("  |");
                }
                if (wrongCount >= 5) {
                    System.out.print("/");
                    if (wrongCount >= 6) {
                        System.out.println(" \\");
                    } else {
                        System.out.println("");
                    }

                    System.out.println("-------");
                    System.out.println("|      |");

                    printWordState(word, playerGuesses);

                    if (!getPlayerGuess(keyboard, word, playerGuesses)) {
                        wrongCount++;
                    }
                    ;


                    if (printWordState(word, playerGuesses)) {
                        System.out.println("Du hast gewonnen!");
                        break;

                    }
                    System.out.println("Bitte hier das ganze Wort lösen.");
                    if (keyboard.nextLine().equals(word)) {
                        System.out.println("Du hast gewonnen!");
                        break;
                    } else {
                        System.out.println("Falsch. Versuch es noch einmal.");
                    }


                }


                private static boolean getPlayerGuess (Scanner keyboard, String word, List < Character > playerGuesses){
                    System.out.println("Bitte gib einen Buchstaben ein.");

                    String letterGuess = keyboard.nextLine();
                    playerGuesses.add(letterGuess.charAt(0));

                    return word.contains(letterGuess);


                }

                private static boolean printWordState (String word, List < Character > playerGuesses){
                    int correctCount = 0;

                    for (int i = 0; i < word.length(); i++) {

                        if (playerGuesses.contains(word.charAt(i))) {
                            System.out.print(word.charAt(i));
                            correctCount++;
                        } else {
                            System.out.print("-");
                        }

                    }
                    ;

                    System.out.println();

                    return (word.length() == correctCount);
                }

            }

Und dann siehst Du, wie Du bei der Prüfung der ganzen wrongCount in der Einrückung immer weiter "abdriftest".
 

KonradN

Super-Moderator
Mitarbeiter
Evtl. als Hilfe einmal eine etwas angepasste Version - ich habe aber die Funktionalität nicht betrachtet sondern nur etwas an den geschweiften Klammern verändert...

Java:
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.io.File;

public class Hangman {

    public static void main(String[] args) throws FileNotFoundException {

        Scanner scanner = new Scanner(new File("C:/Users/49152/Desktop/Woerter.txt"));
        Scanner keyboard = new Scanner(System.in);

        List<String> words = new ArrayList<>();

        while (scanner.hasNext()) {
            words.add(scanner.nextLine());
        }

        Random rand = new Random();
        String word = words.get(rand.nextInt(words.size()));
        System.out.println(word);
        List<Character> playerGuesses = new ArrayList<>();

        int wrongCount = 0;
        while (true) {
            if (wrongCount >= 1) {
                System.out.println("  O");
            }
            if (wrongCount >= 2) {
                System.out.print("\\ ");
            }
            if (wrongCount >= 3) {
                System.out.println(" /");
            } else {
                System.out.println("");
            }
            if (wrongCount >= 4) {
                System.out.println("  |");
            }
            if (wrongCount >= 5) {
                System.out.print("/");
            }
            if (wrongCount >= 6) {
                System.out.println(" \\");
            } else {
                System.out.println("");
            }

            System.out.println("-------");
            System.out.println("|      |");

            printWordState(word, playerGuesses);

            if (!getPlayerGuess(keyboard, word, playerGuesses)) {
                wrongCount++;
            }

            if (printWordState(word, playerGuesses)) {
                System.out.println("Du hast gewonnen!");
                break;

            }
            System.out.println("Bitte hier das ganze Wort lösen.");
            if (keyboard.nextLine().equals(word)) {
                System.out.println("Du hast gewonnen!");
                break;
            } else {
                System.out.println("Falsch. Versuch es noch einmal.");
            }

        }
    }


    private static boolean getPlayerGuess(Scanner keyboard, String word, List<Character> playerGuesses) {
        System.out.println("Bitte gib einen Buchstaben ein.");
        String letterGuess = keyboard.nextLine();
        playerGuesses.add(letterGuess.charAt(0));
        return word.contains(letterGuess);
    }

    private static boolean printWordState(String word, List<Character> playerGuesses) {
        int correctCount = 0;

        for (int i = 0; i < word.length(); i++) {
            if (playerGuesses.contains(word.charAt(i))) {
                System.out.print(word.charAt(i));
                correctCount++;
            } else {
                System.out.print("-");
            }
        }

        System.out.println();
        return (word.length() == correctCount);
    }

}
 

KonradN

Super-Moderator
Mitarbeiter
Müsstest Du vergleichen. Ich hatte in erster Linie geschweifte Klammern hinzugefügt - halt bei den ganzen if (wrongCount ...., so dass diese alle auf einer Ebene sind. Und ich meine, es fehlte dann am Ende noch eine vor der nächsten Methode ...
 

Neue Themen


Oben