Erste Schritte Buchstaben im Array suchen

[auroNpls]

Hallo liebe Leute,

ich habe folgendes Problem bzw. Aufgabe zu bearbeiten:

Ich habe zwei Arrays, einmal ein eindimensionales Character Array "Zeile" (bspw. {O,L,L,A,H}), welches mit Buchstaben gefüllt ist. Dann habe ich noch ein zweidimensionales Character Array "Woerter", in welchem Wörter eingespeichert sind (bspw. Woerter[1][j] = {H,A,L,L,O}).

Nun soll ich die einzelnen Zeichen aus dem Array Wörter mit dem Array Zeile vergleichen und bestimmen, ab welcher Position in dem Array die Wörter beginnen und in welche Richtung dieses Wort geschrieben wird.

Ich hab folgenden Ansatz gewählt:

char[] zeile = {'F','G','C','O','L','L','A','H','R','X','B','E',
            'I','S','P','I','E','L','Y','E','S','U','A','H'};

    char[][] woerter = {
        {'H','A','L','L','O'},
        {'B','E','I','S','P','I','E','L'},
        {'H','A','U','S'},
    };

    for(int i = 0; i < woerter.length; i++) {
        for(int k = 0; k < zeile.length; k++) {
            for(int j = 0; j < woerter[i].length; j++) {
                if(zeile[k] == woerter[i][j]) {
                    System.out.println("ab Position " + k);
                }
        }
    }
    }

Nun würde ich gerne wissen, ob das so überhaupt logisch gedacht ist mein Ansatz bzw. die for-Schleifen richtig gesetzt sind. Ich muss noch dazu sagen, dass wir die getChar()-Methode hier nicht benutzen dürfen bzw. noch nicht hatten.

Vielen Dank schon mal!

 

[mihe7]

Mal von vorne:

1. Du hast eine Liste von Wörtern und eine Zeile, in der evtl. diese Wörter vorkommen, ggf. jedoch in umgekehrter Reihenfolge geschrieben sind.
2. Du sollst diese Wörter finden, auch wenn sie umgekehrt geschrieben in der Zeile stehen
3. Falls es das Wort in der Zeile gibt, sollst Du angeben, ob das Wort in der Zeile in normaler oder umgekehrter Reihenfolge geschrieben ist,
4. außerdem, wo das Wort in der Zeile beginnt.

Der letzte Punkt ist nicht eindeutig. Beginnt "HALLO" in der Zeile "OLLAH" beim O oder beim H?

 

[MoxxiManagarm]

3 verschachtelte Schleifen sind immer unschön wie ich finde...

Mein Vorschlag mit einer Schleife:

package javaforum.org.buchstabenpuzzle;

import java.util.Arrays;


public class Buchstabensuppe {
    public static void main(String... args) {
        char[] zeile = {'F','G','C','O','L','L','A','H','R','X','B','E',
            'I','S','P','I','E','L','Y','E','S','U','A','H'};
       
        char[] wort = {'S','P','I','E','L'};
        char[] reversed = new StringBuilder(String.valueOf(wort))
                .reverse().toString().toCharArray();
       
        for(int i = 0; i <= zeile.length - wort.length; i++) {
            char[] subArray = Arrays.copyOfRange(zeile, i, i + wort.length);
           
            if(Arrays.equals(subArray, wort) || Arrays.equals(subArray, reversed)) {
                System.out.println("Found at: " + i);
            }
        }
    }
}

 

[auroNpls]

Mal von vorne:

1. Du hast eine Liste von Wörtern und eine Zeile, in der evtl. diese Wörter vorkommen, ggf. jedoch in umgekehrter Reihenfolge geschrieben sind.
2. Du sollst diese Wörter finden, auch wenn sie umgekehrt geschrieben in der Zeile stehen
3. Falls es das Wort in der Zeile gibt, sollst Du angeben, ob das Wort in der Zeile in normaler oder umgekehrter Reihenfolge geschrieben ist,
4. außerdem, wo das Wort in der Zeile beginnt.

Der letzte Punkt ist nicht eindeutig. Beginnt "HALLO" in der Zeile "OLLAH" beim O oder beim H?

Sorry für die komplizierte Erklärung. In diesem Fall beginnt es bei "H", welches auf der Position 7 wäre (wenn man von 0 anfängt zu zählen) und ist nach links geschrieben. Die Ausgabe wäre dann in diesem Fall "ab Position 9 <--- HALLO", wobei der Pfeil "<---" andeutet in welche Richtung das Wort geschrieben wird. Also hätte ich zwei Pfeile "--->" für Wörter die in der Zeile vorkommen von links nach rechts und "<---" für Wörter die vorkommen von rechts nach links.

 

[auroNpls]

3 verschachtelte Schleifen sind immer unschön wie ich finde...

Mein Vorschlag mit einer Schleife:

package javaforum.org.buchstabenpuzzle;

import java.util.Arrays;


public class Buchstabensuppe {
    public static void main(String... args) {
        char[] zeile = {'F','G','C','O','L','L','A','H','R','X','B','E',
            'I','S','P','I','E','L','Y','E','S','U','A','H'};
      
        char[] wort = {'S','P','I','E','L'};
        char[] reversed = new StringBuilder(String.valueOf(wort))
                .reverse().toString().toCharArray();
      
        for(int i = 0; i <= zeile.length - wort.length; i++) {
            char[] subArray = Arrays.copyOfRange(zeile, i, i + wort.length);
          
            if(Arrays.equals(subArray, wort) || Arrays.equals(subArray, reversed)) {
                System.out.println("Found at: " + i);
            }
        }
    }
}

Ich glaube leider nicht, dass ich ein drittes bzw. viertes Array hinzufügen darf. Also ich soll mit dem Array "woerter" in dem Array "zeile" die einzelnen Character finden und überprüfen, ab welcher Position das Wort (Position des Anfangsbuchstabens des Wortes in dem Array "Zeile") enthalten ist und in welche Richtung es geschrieben wird. (siehe Post darüber)

 

[MoxxiManagarm]

Warum solltest du keine Hilfsarrays hinzufügen dürfen? Die Ausgabe kannst du ja entsprechend gestalten.

 

[mihe7]

Es wäre natürlich schöner, wenn Du z. B. weitere Arrays hinzufügen dürftest, aber gut. Vermutlich auch keine eigenen Methoden...

Die einfachste Variante ist immer noch die, für jede Position der Zeile zu prüfen, ob ein Wort beginnt:

for (int w = 0; w < woerter.length; w++) {
    char[] wort = woerter[w]; // falls verboten -> Ersetzung unten
    for (int i = 0; i < zeile.length - wort.length + 1; i++) {
        boolean enthalten = true;
        for (int j = 0; enthalten && j < wort.length; j++) {
            enthalten = zeile[i + j] == wort[j];
        }
        if (enthalten) { 
            // gib "ab Position i ----> wort" aus
        }
    }
    // analog nochmal für die Rückrichtung
}

 

[auroNpls]

Es wäre natürlich schöner, wenn Du z. B. weitere Arrays hinzufügen dürftest, aber gut. Vermutlich auch keine eigenen Methoden...

Die einfachste Variante ist immer noch die, für jede Position der Zeile zu prüfen, ob ein Wort beginnt:

for (int w = 0; w < woerter.length; w++) {
    char[] wort = woerter[w]; // falls verboten -> Ersetzung unten
    for (int i = 0; i < zeile.length - wort.length + 1; i++) {
        boolean enthalten = true;
        for (int j = 0; enthalten && j < wort.length; j++) {
            enthalten = zeile[i + j] == wort[j];
        }
        if (enthalten) {
            // gib "ab Position i ----> wort" aus
        }
    }
    // analog nochmal für die Rückrichtung
}

Zu der Rückrichtung, die ich analog machen soll:

    for(int w = woerter.length - 1; w >= 0; w--) {
       char[] wort = woerter[w];
       for(int i = zeile.length - 1; i >= wort.length - 1; i--) {
           boolean enthalten = true;
           for(int j = wort.length - 1; enthalten && j >= 0; j--) {
               enthalten = zeile[i - j] == wort[j];
               }
           if (enthalten) {
               System.out.print("Ab Position " + (i+1) + " <--- ");
               System.out.print(wort);
               System.out.println();
              
           }  
       }
   }

Hier erhalte ich als Ausgabe zwar die richtigen Positionen, nur in aufsteigender Reihenfolge.

D.h.

Ab Position 4 ---> wort
Ab Position 11 ---> wort
Ab Position 30 ---> wort
Ab Position 3 <--- wort
Ab Position 25 <--- wort
Ab Position 29 <--- wort
Ab Position 36 <--- wort

Stattdessen sollte die Ausgabe so aussehen:

Ab Position 4 ---> wort
Ab Position 11 ---> wort
Ab Position 30 ---> wort
Ab Position 36 <--- wort
Ab Position 29 <--- wort
Ab Position 25 <--- wort
Ab Position 3 <--- wort

Habe meinen Fehler entdeckt!

for(int w = 0; w < woerter.length; w++) {
       char[] wort = woerter[w];
       for(int i = zeile.length - 1; i >= wort.length - 1; i--) {
           boolean enthalten = true;
           for(int j = wort.length - 1; enthalten && j >= 0; j--) {
               enthalten = zeile[i - j] == wort[j];
               }
           if (enthalten) {
               System.out.print("Ab Position " + (i+1) + " <--- ");
               System.out.print(wort);
               System.out.println();
            
           }
       }
   }

So müsste die Rückwärtsschleife lauten!

 

[mihe7]

Ja, sieht richtig aus. Je nachdem, ob Du die Ausgabe nach Hin- und Rückrichtung gruppiert haben willst, kannst Du die zwei woerter-for-Schleifen nacheinander ausführen oder zu einer zusammenfassen.