Schwierigkeitsgrad eines Wortes mit Morsecode ermitteln

[Java_Starter012]

Hallo zusammen,

ich verzweifel jetzt seit Stunden an einer Aufgabe und auch google konnte mir nicht weiterhelfen. Da dachte ich mir ich probiers mal hier

Ich habe die Aufgabe, das Spiel Hangman zu implementieren. Zuerst soll als Input das zu erratende Wort übergeben werden. Ich hab jetzt mal "Haus" ausgewählt (Groß-/Kleinschreibung irrelevant). Danach soll für das Wort der Schwierigkeitsgrad errechnet werden und zwar mit dem Morsealphabet. Die Anzahl der Buchstaben im Morsecode soll aufsummiert werden und die Summe ist der Schwierigkeitswert. A hat zum Beispiel den Wert 2.

Im Moment ist es mir zwar insgesamt noch ein Rätsel wie ich das jemals halbwegs hinbekommen soll, aber an diesem Morse Zeug verzweifle ich komplett. Ich hab mal so angefangen, dass ich Versuche die Buchstaben mit den jeweiligen Werten zu verbinden... und dann sollte eben berechnet werden aus wie vielen Werten Haus besteht. Also die Morsewerte für H A U S müssen berechnet werden und werden als Schwierigkeitsgrad ausgegeben. Vielleicht weiß ja jemand weiter, ich würde mich sehr freuen. Danke

public static void main(String[] args) {
// TODO Auto-generated method stub
String hangmanWord = "Haus"; //das gesuchte Wort lautet Haus
String[] alpha = { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j",
"k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v",
"w", "x", "y", "z" };
String[] alphaMorse = { "2", "4", "4", "3", "1", "4", "3",
"4", "2", "4", "3", "4", "2", "2", "3", "4",
"4", "3", "3", "1", "3", "4", "3", "4",
"4", "4" };
String smallBig = smallBig.toLowerCase().toUpperCase(); //Groß/Kleinschreibung irrelevant

}
}

 

[JCODA]

Speichere die "Werte" doch als Integer(-Array), dann kannst du damit rechnen.
Also du brauchst jetzt noch eine Variable die dir die Gesamtschwierigkeit speichert.
Dann musst du mit einer Schleife über dein Wort iterieren, und zu jedem Buchstaben den zugehörigen Wert raussuchen und zu deiner Gesamtschwierigkeit addieren.

 

[Javinner]

Danach soll für das Wort der Schwierigkeitsgrad errechnet werden und zwar mit dem Morsealphabet

Was meinst du damit?

 

[Java_Starter012]

Was meinst du damit?

Also das Morsealphabet soll sozusagen zweckentfremdet werden indem man sagt je mehr Zeichen ein Buchstabe (abc..) im Morsealphabet hat, desto schwieriger ist das Wort zu erraten in dem hangman Spiel. E hat z.b nur ein Zeichen. Also würde als wert 1 einfließen und ist damit sehr niedrig. Ich muss es also so programmieren, dass ich zuerst das abc Alphabet mit dem Morsealphabet verbinde. Das Morsealphabet wird aber umgewandelt in die jeweilige Zeichenanzahl pro Buchstabe. Dann soll für mein Wort, also "Haus" ausgerechnet werden wie viele Zeichen die Buchstaben H A U S im Morsealphabet benötigt. Also die Anzahl Zeichen von h plus Anzahl Zeichen von a etc. Die Summe dieser Werte ergibt den Schwierigkeitswert mit dem das Wort zu erraten ist.
Es geht also nicht darum mein Wort in den Morse Code zu übersetzen. Das ganze soll nur ein weiteres Feature im hangman Spiel darstellen.
Der Weg, den der andere User oben beschrieben hat, hört sich denk ich schon ganz plausibel an
Ich frage mich im Moment nur noch wie ich das genau in Java implementiere

 

[Javinner]

Ich halte fest:
Wort: HAUS
Morsezeichen: ....|.-|..-|... : 12 Zeichen(Trennwände nur zur Übersicht)
Also hat das Wort "Haus" die Schwierigkeit 12, ist es richtig?

 

[Javinner]

Der Vorschlag von @JCODA ist sehr gut!
Ich würde dies ebenso machen. Dein Problem lässt sich so lösen:

package test;

public class Test
{
    public static void main(String[] args)
    {
        String morseZeichen = "....";
        System.out.println(morseZeichen.length());
        int i = morseZeichen.length();
        System.out.println(i * 2);
      
    }
}
/** Konsolenausgabe: 4, 8*/

Schau hier rein, dass könnte hilfreich sein
https://www.java-forum.org/thema/wachsen-mit-dem-buch-java-ist-auch-eine-insel.178873/

 

[Java_Starter012]

Ich halte fest:
Wort: HAUS
Morsezeichen: ....|.-|..-|... : 12 Zeichen(Trennwände nur zur Übersicht)
Also hat das Wort "Haus" die Schwierigkeit 12, ist es richtig?

ja genau.

 

[Java_Starter012]

Der Vorschlag von @JCODA ist sehr gut!
Ich würde dies ebenso machen. Dein Problem lässt sich so lösen:

package test;

public class Test
{
    public static void main(String[] args)
    {
        String morseZeichen = "....";
        System.out.println(morseZeichen.length());
        int i = morseZeichen.length();
        System.out.println(i * 2);
     
    }
}
/** Konsolenausgabe: 4, 8*/

Schau hier rein, dass könnte hilfreich sein
https://www.java-forum.org/thema/wachsen-mit-dem-buch-java-ist-auch-eine-insel.178873/

Vielen Dank das werd ich gleich mal ausprobieren. Den Beitrag hab ich auch schon gesehen. Könnte es aber noch nicht ganz auf mein Problem anwenden :/

Das Buch ist jedenfalls gut. Auf dem baut auch die Aufgabe auf

 

[Javinner]

Vielen Dank das werd ich gleich mal ausprobieren. Den Beitrag hab ich auch schon gesehen. Könnte es aber noch nicht ganz auf mein Problem anwenden :/
Das Buch ist jedenfalls gut. Auf dem baut auch die Aufgabe auf

Ja ja.. Kapitel 4 "Der Umgang mit Zeichenketten" lerne gut, etwas weiter wird es fördernd

 

[Javinner]

run:
HAUS
.... | .- | ..- | ...
Gesamtanzahl der Morsezeichen für das Wort: HAUS beträgt: 12 Zeichen
BUILD SUCCESSFUL (total time: 3 seconds)

 

[Java_Starter012]

Speichere die "Werte" doch als Integer(-Array), dann kannst du damit rechnen.
Also du brauchst jetzt noch eine Variable die dir die Gesamtschwierigkeit speichert.
Dann musst du mit einer Schleife über dein Wort iterieren, und zu jedem Buchstaben den zugehörigen Wert raussuchen und zu deiner Gesamtschwierigkeit addieren.

Ich hab mal versucht nach deiner Empfehlung vorzugehen. Kannst du mir kurz sagen, ob ich das int Array generell so richtig gemacht habe und wie ich dann bei der Schleife vorgehe, dass die einzelnen Buchstaben den Werten im int Array zugeordnet werden und aufsummiert werden?

public static void main(String[] args) {
// TODO Auto-generated method stub
String hangmanWord = "Haus"; //das gesuchte Wort lautet Haus
String[] alpha = { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j",
"k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v",
"w", "x", "y", "z" };
int[] morseArray = new int[] {2,4,4,3,1,4,3,4,2,4,3,4,2,2,3,4,
4,3,3,1,3,4,3,4,4,4};
sumMorse(alpha, morseArray, hangmanWord);
}
static void sumMorse(String[] alpha, int[] morseArray, String hangmanWord)
{ for (..);

}

 

[Lamajockey]

Moin, da du schon zwei Arrays hast nutze ich die doch mal.

        String hangmanWord = "Haus"; 
        int wortwert=0;
        char[] wertString = hangmanWord.toLowerCase().toCharArray();
        String[] alpha = { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j",
                                "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v",
                                "w", "x", "y", "z" };
        int[] alphaMorse = { 2, 4, 4, 3, 1, 4, 3, 4, 2, 4, 3, 4, 2, 2, 3, 4, 4, 3, 3, 1, 3, 4, 3, 4, 4, 4 };      
        for (int i=0;i< wertString.length;i++) {
            for(int j=0;j<alpha.length;j++){
                if(wertString[i]==alpha[j].charAt(0)){
                    wortwert+=alphaMorse[j];
                    System.out.println(wertString[i] +" hat einen Wert von "+ alphaMorse[j]);
                }   
            }
        }
        System.out.println("Für das Wort \"" + hangmanWord + "\" gibt es "+wortwert + " Punkte");

 

[Java_Starter012]

Moin, da du schon zwei Arrays hast nutze ich die doch mal.

        String hangmanWord = "Haus";
        int wortwert=0;
        char[] wertString = hangmanWord.toLowerCase().toCharArray();
        String[] alpha = { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j",
                                "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v",
                                "w", "x", "y", "z" };
        int[] alphaMorse = { 2, 4, 4, 3, 1, 4, 3, 4, 2, 4, 3, 4, 2, 2, 3, 4, 4, 3, 3, 1, 3, 4, 3, 4, 4, 4 };     
        for (int i=0;i< wertString.length;i++) {
            for(int j=0;j<alpha.length;j++){
                if(wertString[i]==alpha[j].charAt(0)){
                    wortwert+=alphaMorse[j];
                    System.out.println(wertString[i] +" hat einen Wert von "+ alphaMorse[j]);
                }  
            }
        }
        System.out.println("Für das Wort \"" + hangmanWord + "\" gibt es "+wortwert + " Punkte");

Funktioniert vielen vielen Dank!! ich bin dir wirklich seeehr dankbar
hast du zufällig noch einen Tipp wie ich es implementieren kann, dass der Schwierigkeitsgrad nicht nur am Anfang des Spiels gedruckt wird, sondern auch dann wenn der User einen bestimmten Buchstaben in die Konsole eingibt (mit der Scanner Methode.. also zum Beispiel user gibt "g" in die Konsole ein und dann erscheint die Info

 

[Xyz1]

Hallo, eigentlich ist das recht Easy easy:

    public static void main(String[] args) {
        char[] a = "xxTEMNAIOGKDWRUS-.QZYCXBJPxL-FVH09x8xxx7xxxxxxx61xxxxxxx2xxx3x45".toCharArray();
        int[][] morseAndDifficult = new int[a.length][2];
        for (int i = 2; i < a.length; i++) {
            System.out.println(i + " " + a[i] + " " + morse(a, i) + "  (" + difficult(a, i) + ")");
            morseAndDifficult[i] = new int[]{a[i], difficult(a, i)};
        }
        System.out.println();
        Arrays.sort(morseAndDifficult, (int[] o1, int[] o2) -> o1[1] - o2[1]);
        for (int i = 0; i < morseAndDifficult.length; i++) {
            System.out.println((char) morseAndDifficult[i][0] + " " + morseAndDifficult[i][1]);
        }
    }

    private static String morse(char[] a, int index) {
        String string = "";
        while (index != 0) {
            if ((index % 2) == 1) {
                string = "." + string;
            } else {
                string = "-" + string;
            }
            index = index / 2;
        }
        return string.substring(1) + " ";
    }

    private static int difficult(char[] a, int index) {
        char[] array = morse(a, index).toCharArray();
        int summe = 0;
        for (int i = 0; i < array.length - 1; i++) {
            if (array[i] == array[i + 1]) {
                summe++;
            } else {
                summe = summe + 2;
            }
        }
        return summe;
    }

2 T -   (2)
3 E .   (2)
4 M --   (3)
5 N -.   (4)
6 A .-   (4)
7 I ..   (3)
8 O ---   (4)
9 G --.   (5)
10 K -.-   (6)
11 D -..   (5)
12 W .--   (5)
13 R .-.   (6)
14 U ..-   (5)
15 S ...   (4)
16 - ----   (5)
17 . ---.   (6)
18 Q --.-   (7)
19 Z --..   (6)
20 Y -.--   (7)
21 C -.-.   (8)
22 X -..-   (7)
23 B -...   (6)
24 J .---   (6)
25 P .--.   (7)
26 x .-.-   (8)
27 L .-..   (7)
28 - ..--   (6)
29 F ..-.   (7)
30 V ...-   (6)
31 H ....   (5)
32 0 -----   (6)
33 9 ----.   (7)
34 x ---.-   (8)
35 8 ---..   (7)
36 x --.--   (8)
37 x --.-.   (9)
38 x --..-   (8)
39 7 --...   (7)
40 x -.---   (8)
41 x -.--.   (9)
42 x -.-.-   (10)
43 x -.-..   (9)
44 x -..--   (8)
45 x -..-.   (9)
46 x -...-   (8)
47 6 -....   (7)
48 1 .----   (7)
49 x .---.   (8)
50 x .--.-   (9)
51 x .--..   (8)
52 x .-.--   (9)
53 x .-.-.   (10)
54 x .-..-   (9)
55 x .-...   (8)
56 2 ..---   (7)
57 x ..--.   (8)
58 x ..-.-   (9)
59 x ..-..   (8)
60 3 ...--   (7)
61 x ...-.   (8)
62 4 ....-   (7)
63 5 .....   (6)

T 2
E 2
M 3
I 3
N 4
A 4
O 4
S 4
G 5
D 5
W 5
U 5
- 5
H 5
K 6
R 6
. 6
Z 6
B 6
J 6
- 6
V 6
0 6
5 6
Q 7
Y 7
X 7
P 7
L 7
F 7
9 7
8 7
7 7
6 7
1 7
2 7
3 7
4 7
C 8
x 8
x 8
x 8
x 8
x 8
x 8
x 8
x 8
x 8
x 8
x 8
x 8
x 8
x 9
x 9
x 9
x 9
x 9
x 9
x 9
x 9
x 10
x 10

x - und . sind Platzhalter!
Jetzt wird auch schnell klar, Warum die Zahlen im Binärbaum (Morsealphabet) so gelegt wurden, wie sie gelegt wurden.

Ich habe das Ganze auch auf Richtigkeit überprüft, ich garantiere aber KEINE Richtigkeit. (Also falls wer SOS morsen möchte, der nehme bitte ne offizielle Tabelle).

 

[Lamajockey]

Moin,
da du bei Hangman ja eh die Tastaureingabe verarbeitest könntest du ja
beim eingeben von z.B. '?' die Info ausgeben.
Ein direktes reagieren via 'KeyListner' ist bei Konsolenanwendungen soviel ich weiß nicht möglich.

 

[Trjavnamen]

oder nach dem Beispiel anstatt String (zahl), String (..-) Zusammengesetzt ist es dann String GanzesWort = (" .... | .- | ..- | ...") int Schwierigkeitsgrad = GanzesWort.length()

 

[Xyz1]

Er könnte für Buchstaben einfach die Methode difficult() verwenden und für Wörter die Schwierigkeit der einzelnen Buchstaben zusammen zählen - dadurch wird auch die Länge des Worts (und des Buchstabens) berücksichtigt.

 

[Java_Starter012]

Danke an alle für die Antworten.

Moin,
da du bei Hangman ja eh die Tastaureingabe verarbeitest könntest du ja
beim eingeben von z.B. '?' die Info ausgeben.
Ein direktes reagieren via 'KeyListner' ist bei Konsolenanwendungen soviel ich weiß nicht möglich.

Genau, also ich würde das dann über ne if Schleife machen oder? Falls Eingabe von bestimmten Zeichen, dann Ausgabe von gefragter Info...

 

[Lamajockey]

Jepp