B-Sprache mit Arrays ausführen

[Joggle02]

Hallo zusammen,
ich sitze gerade hier am Studium und komme nicht weiter.
Folgende Aufgabe müssen wir lösen:
Schreiben Sie eine Methode namens spielen, die ein normales Wort entgegennimmt (Parameterdatentyp: String) und in ein Wort der B-Sprache übersetzt und dieses zurückgibt.
Beispiel:
übergebene Zeichenfolge: spiel mit mir
zurückgelieferte Zeichenfolge: spibiebel mibit mibir
Hinweise:
Verwenden Sie zur Lösung der Aufgabe keine Methoden der Klasse String außer toCharArray() und String.valueOf()!
Vorgehensweise:

• - Wandeln Sie den an die Methode übergebenen String mit toCharArray() in ein char-Array um!
• - Ermitteln Sie, wie lang der zurückzugebende String sein muss und erzeugen Sie ein neues char-Array der entsprechenden Länge. Speichern Sie in diesem char-Array das Wort der B-Sprache.
• - Wandeln Sie das neue char-Array mit String.valueOf() zurück in einen String um und geben Sie diesen zurück.

Leider komme ich nicht weiter an meiner bisherigen Arbeit und bräuchte dabei nun etwas Hilfe 😉
Vielen Dank schonmal im Vorraus.

Java:

public class Übung4c {
    
    public static String spielen(String zeichenfolge) {
        
        char[] array = zeichenfolge.toCharArray();
        int zaehler = 0;
        
        for (int i = 0; i < array.length; i++) {
            
            if (array[i] == 'a' || array[i] == 'e' || array[i] == 'i' || array[i] == 'o' || array[i] == 'u')
                
            {   
                zaehler = zaehler + 2;
            }
        }
        
        char[] arrayneu = new char[array.length + zaehler];
        
        for (int j = 0; j < array.length; j++) {
            arrayneu[j] = array[j];
        }
        for (int l = 0; l < arrayneu.length; l++) {
            
            System.out.println(arrayneu[l]);
            
            
        }
        
        for (int k = 0; k < arrayneu.length; k++) {
            
            if (arrayneu[k] == 'a' || arrayneu[k] == 'e' || arrayneu[k] == 'i' || arrayneu[k] == 'o' || arrayneu[k] == 'u')
                for (int j = k; j < arrayneu.length; j++) {
                    arrayneu[k+2] = arrayneu[k];
            }
            
            arrayneu[k + 1] = 'b';
            arrayneu[k + 2] = arrayneu[k];
                    }
        
        String str = String.valueOf(arrayneu);
        return zeichenfolge;
        
    }
    public static void main(String[] args) {
        String zeichenfolge = "Spiel mit mir";
        System.out.print(spielen(zeichenfolge));
        
        }
}

 

[httpdigest]

Bitte paste doch den Quellcode nicht als Screenshot, sondern als Text (im code-Tag).
Wenn du jemandem eine E-Mail schreibst, dann schreibst du den Text ja auch vorhin nicht in MS Word, machst dann einen Screenshot davon und fügst das Bild als einzigen Anhang an die E-Mail)...

 

[Joggle02]

Bitte paste doch den Quellcode nicht als Screenshot, sondern als Text (im code-Tag).
Wenn du jemandem eine E-Mail schreibst, dann schreibst du den Text ja auch vorhin nicht in MS Word, machst dann einen Screenshot davon und fügst das Bild als einzigen Anhang an die E-Mail)...

Sorry ich habe gedacht dass man so alles besser erkennen kann...

 

[fhoffmann]

        String str = String.valueOf(arrayneu);
        return zeichenfolge;

Da gibst du den falschen String zurück.

 

[Joggle02]

        String str = String.valueOf(arrayneu);
        return zeichenfolge;

Da gibst du den falschen String zurück.

Welchen String müsste ich zurückgeben?

 

[mrBrown]

Welchen String müsste ich zurückgeben?

Wahrscheinlich den, den du in der Zeile vor dem return erstellst.

 

[Joggle02]

Wahrscheinlich den, den du in der Zeile vor dem return erstellst.

Klappt leider auch nicht.

 

[kneitzel]

Was heißt genau "Klappt leider auch nicht!". Was ist das genaue Problem? Was konntest Du bisher analysieren?

Und Wenn Du weisst, was er wann wo machen soll: Dann geh mit dem Debugger durch oder geh einfach hin und gib Zwischenergebnisse aus, damit Du siehst, ob das, was Du machst, korrekt ist..

 

[fhoffmann]

                for (int j = k; j < arrayneu.length; j++) {
                    arrayneu[k+2] = arrayneu[k];

Das sieht komisch aus - du hast eine Schleife über j, benutzt j aber gar nicht.

 

[kneitzel]

Da sieht vieles komisch aus ... selbst wenn er k in der Schleife durch j ersetzt: Dann geht er bis arrayneu.length-1 und greift auf das Element mit +2 zu...
Und er kopiert immer Inhalt zwei weiter ... also z.B. 2->4, 3->5, 4 (das ehemalige 2) -> 6, ....

Wenn er das alles behoben hat, dann behandelt er einen Buchstaben bei Position k. Dazu verschiebt er alles dahinter kommende um 2 Zeichen um dann b und den Buchstaben zu kopieren ... dann läuft er weiter und behandelt die eingefügten Buchstaben ...

Also aus meiner Sicht relativ kompliziert gedacht und dann mehrere Fehler eigebaut.

We würde man das denn machen, wenn man es manuell machen würde (Also mit Stift und Papier)?
Buchstabe für Buchstabe lesen.
- ist es kein Vokal, dann wird der Buchstabe geschrieben+
- ist es ein Vokal, dann wird der Buchstabe, b, und wieder der Buchstabe geschrieben.

Dann spart man sich viel Kopieren und so ....

 

[fhoffmann]

Ja,

das ewige Kopieren ist mir auch aufgefallen. Natürlich würde ich das Programm auch anders planen.
Aber mit ein paar kleinen Änderungen sollte das Programm auch so zum Laufen zu kriegen sein.
Hier kommt es doch darauf an, dass das Programm tut, was es soll, und die Effektivität spielt nur eine zweite Rolle (insbesondere, wenn ich mit Testwerten wie "spiel mit mir" arbeite).

Und für "Joggle02": Du solltest zunächst den falschen Code

for (int j = k; j < arrayneu.length; j++) {
   arrayneu[k+2] = arrayneu[k];

korrigieren und dir dann überlegen, weshalb du eine IndexOutOfBoundException bekommst.

(Edit): Ich sehe erst nun, dass das Kopieren von "hinten nach vorne" erfolgen muss. Das ist dann möglicherweise doch nicht so trivial. - Hätte den Beitrag von Kneitzel vorher gründlicher lesen sollen)

 

[kneitzel]

Also die Idee lässt sich natürlich zum Laufen kriegen und ich gebe Dir Recht, das die Effektivität nicht ganz so wichtig ist.

So gesehen kann es sogar ein Gute Übung sein bezüglich Debugging / Fehlersuche.

Diesbezüglich könnte es auch Sinn machen, das Problem in Teilprobleme zu unterteilen:
Dann packt man Teile in Methoden, z.B. das verschieben von Elementen um 2 Plätze ab einem Startpunkt. Das ist dann evtl. einfacher zu testen ...

 

[Joggle02]

Hallo zusammen
Ich habe über Nacht folgendermaßen das Problem gelöst.
Das Programm nimmt nun über einen Scanner einen eingelesenen Satz entgegen und gibt ihn dann in B-Sprache zurück.
Vielen Dank für Hilfe sodass der Code nun das ausführt was er machen soll 🙂

import java.util.Scanner;

public class Übung4 {
    
    public static String spielen(String zeichenfolge) {
        
        char[] array = zeichenfolge.toCharArray();
        int zaehler = 0;
        
        for(int i = 0; i < array.length; i++) {
            if (array[i] =='a' || array[i] =='e' ||array[i] =='i' ||array[i] =='o' ||array[i] =='u'){
                zaehler = zaehler + 2;
            }
        }
            
        char[] arrayneu = new char[array.length + zaehler];

        for (int j = 0; j < array.length; j++) {
            arrayneu[j] = array[j];
        }

        int hilf=0;

        for(int k = 0; k < array.length; k++) {
            if (array[k] =='a' || array[k] =='e' ||array[k] =='i' ||array[k] =='o' ||array[k] =='u') {
                
                arrayneu[k+hilf] = array[k];
                hilf++;
                arrayneu[k+hilf]= 'b';
                hilf++;
                arrayneu[k+hilf]= array[k];
            }
            
            else {
                arrayneu[k+ hilf]= array[k];
            }
                
        }
        
        String str = String.valueOf(arrayneu);
        return str;
        
    }
    public static void main(String[] args) {
        
        Scanner scanner= new Scanner(System.in);
        System.out.println("Geben Sie eine Zeichenfolge ein:");
        String zeichenfolge = scanner.nextLine();

        System.out.println("In B-Sprache: " + "\n" + spielen(zeichenfolge));
        scanner.close();
        
        }
}

 

[kneitzel]

Sehr schön. Und die Lösung ist entgegen dem ersten Ansatz, nun deutlich weniger komplex. 🙂

 

[Joggle02]

Sehr schön. Und die Lösung ist entgegen dem ersten Ansatz, nun deutlich weniger komplex. 🙂

Ja schon vielen Dank Ihnen für die Hilfe 🙂

 

[mihe7]

Man kann das noch etwas weniger komplex gestalten: die Zeilen 18 bis 20 sind überflüssig 🙂

 

[Joggle02]

Man kann das noch etwas weniger komplex gestalten: die Zeilen 18 bis 20 sind überflüssig 🙂

Stimmt da j nicht gebraucht wird kann man dies einfach weglassen. Ist wahrscheinlich noch vom Ansatz stehengeblieben .
Dankeschön 🙂

 

[kneitzel]

Ja, das wird vom anderen versuch übrig geblieben sein... aber nur aus Jux und Dollerei: Der andere Ansatz würde natürlich auch funktionieren:

public class Übung4c {
    
    public static String spielen(String zeichenfolge) {
        
        char[] array = zeichenfolge.toCharArray();
        int zaehler = 0;
        
        for (int i = 0; i < array.length; i++) {
            
            if (array[i] == 'a' || array[i] == 'e' || array[i] == 'i' || array[i] == 'o' || array[i] == 'u') {   
                zaehler = zaehler + 2;
            }
        }
        
        char[] arrayneu = new char[array.length + zaehler];
        
        for (int j = 0; j < array.length; j++) {
            arrayneu[j] = array[j];
        }
        
        for (int k = 0; k < arrayneu.length-2; k++) {
            System.out.println(String.valueOf(arrayneu) + " K: " + k);
            if (arrayneu[k] == 'a' || arrayneu[k] == 'e' || arrayneu[k] == 'i' || arrayneu[k] == 'o' || arrayneu[k] == 'u') {
                for (int j = arrayneu.length-3; j > k ; j--) {
                    arrayneu[j+2] = arrayneu[j];
                }
                arrayneu[k + 1] = 'b';
                arrayneu[k + 2] = arrayneu[k];
                k+=2;
                System.out.println(String.valueOf(arrayneu));
            }
        }
        String str = String.valueOf(arrayneu);
        return str;
        
    }
    public static void main(String[] args) {
        String zeichenfolge = "Spiel mit mir";
        System.out.print(spielen(zeichenfolge));
        
        }
}

Ich habe auch noch zusätzliche Hilfsausgaben eingebaut - die helfen etwas bei der Fehlersuche ... Sowas in der Art kann einem beim Suchen von Problemen durchaus weiter helfen...

 

[Blender3D]

Ich habe über Nacht folgendermaßen das Problem gelöst.

Mit Hilfe von Methoden kann man spielen etwas übersichtlicher machen.
[CODE lang="java" title="B Word" highlight="15-30"]import java.util.Scanner;

public class Übung4C {
// define vocals
private final static char[] vocals = { 'a', 'e', 'i', 'o', 'u' };

public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("Geben Sie eine Zeichenfolge ein:");
String zeichenfolge = in.nextLine();
System.out.println("Wort:\t" + zeichenfolge);
System.out.println("B-Wort:\t" + spielen(zeichenfolge));
}

public static String spielen(String word) {
char[] charWord = word.toCharArray();
int enlargeCount = getEnlargeCount(charWord);
if (enlargeCount == 0)
return word;
char[] charBword = new char[charWord.length + enlargeCount];
int idBword = 0;
for (int idWord = 0; idWord < charWord.length; idWord++) {
charBword[idBword++] = charWord[idWord];
if (isVocal(charWord[idWord])) {
charBword[idBword++] = 'b';
charBword[idBword++] = charWord[idWord];
}
}
return String.valueOf(charBword);
}

private static int getEnlargeCount(char[] charWord) {
int cnt = 0;
for (int i = 0; i < charWord.length; i++) {
if (isVocal(charWord))
cnt += 2;
}
return cnt;
}

private static boolean isVocal(char c) {
for (int i = 0; i < vocals.length; i++) {
if (vocals == c)
return true;
}
return false;
}
}[/CODE]