Gleiche Buchstaben Aufage

[parrot]

Hallo Leute ich weiß nicht wie ich anfangen kann.

Realisieren Sie eine Klasse GleicheBuchstaben mit einer statischen Methode public static
String gibLaengstesKonstantesStueck(String), die das längste Teilwort der übergebenen
Zeichenkette liefert, in dem alle Zeichen gleich sind. Gibt es mehrere solche Teilwörter, die gleich
lang sind, soll die Methode das erste davon liefern.

 

[kneitzel]

Fang immer damit an dir zu überlegen, wie Du vorgehen würdest. Dir wird eine Zeichenkette gegeben und du sollst nun genau diese Thematik manuell heraus finden.
Wie gehst du vor?

 

[temi]

Hallo Leute ich weiß nicht wie ich anfangen kann.

Ich helfe dir mal mit dem Anfang

public static String gibLaengstesKonstantesStueck(String s) {
    // hier kommt jetzt dein Code rein
}

Bevor du jetzt anfängst deinen Code zu schreiben, mach das was @JustNobody dir geraten hat: Überlege dir erst mal, ohne irgendwelchen Code, wie du das manuell, z.B. auf einem Stück Papier machen würdest.

 

[parrot]

Ich helfe dir mal mit dem Anfang

public static String gibLaengstesKonstantesStueck(String s) {
    // hier kommt jetzt dein Code rein
}

Bevor du jetzt anfängst deinen Code zu schreiben, mach das was @JustNobody dir geraten hat: Überlege dir erst mal, ohne irgendwelchen Code, wie du das manuell, z.B. auf einem Stück Papier machen würdest.

Danke.Aber das hatte ich schon.

 

[parrot]

Fang immer damit an dir zu überlegen, wie Du vorgehen würdest. Dir wird eine Zeichenkette gegeben und du sollst nun genau diese Thematik manuell heraus finden.
Wie gehst du vor?

Danke für deine Antwort. ich hab mir die Zeichenkette "Ananas" genommen. Ich weiss jetzt nicht ob das längste Teilwort der übergebenen Zeichenkette sich selbst ist.

 

[temi]

Danke für deine Antwort. ich hab mir die Zeichenkette "Ananas" genommen. Ich weiss jetzt nicht ob das längste Teilwort der übergebenen Zeichenkette sich selbst ist.

Also ich verstehe das so, dass du gleiche Buchstaben hintereinander suchen sollst. Bei "Ananas" wäre demnach die Lösung "A".

 

[parrot]

Fang immer damit an dir zu überlegen, wie Du vorgehen würdest. Dir wird eine Zeichenkette gegeben und du sollst nun genau diese Thematik manuell heraus finden.
Wie gehst du vor?

for(int laenge = wort.length(); laenge > 0; laenge = laenge -1) {

}

 

[parrot]

Also ich verstehe das so, dass du gleiche Buchstaben hintereinander suchen sollst. Bei "Ananas" wäre demnach die Lösung "A".

ja und das längste Teilwort der übergebenen Zeichenkette zurückgeben.

 

[kneitzel]

Also Du sollst in Worten beschreiben, wie Du vorgehst. Da bringt so eine leere for Schleife irgendwie nichts.

Daher noch einmal ganz deutlich: Vergiss jeglichen Java Code! Umschreibe in Worten, wie Du bei einem gegebenen Wort vorgehst.

Also Du kriegst einen Zettel mit: "aabcdddeffaaacee"

Wie gehst du vor um die Lösung zu finden? Und was wäre hier die Lösung?

 

[parrot]

Also Du sollst in Worten beschreiben, wie Du vorgehst. Da bringt so eine leere for Schleife irgendwie nichts.

Daher noch einmal ganz deutlich: Vergiss jeglichen Java Code! Umschreibe in Worten, wie Du bei einem gegebenen Wort vorgehst.

Also Du kriegst einen Zettel mit: "aabcdddeffaaacee"

Wie gehst du vor um die Lösung zu finden? Und was wäre hier die Lösung?

Ich würde erstmal gucken welche Zeichen, die hintereinander gleich sind. Danach zähle ich die und gebe dann das Teilwort zurück.

Hier ist ""aaa" das Ergebnis oder.

 

[kneitzel]

Realisieren Sie eine Klasse GleicheBuchstaben mit einer statischen Methode public static
String gibLaengstesKonstantesStueck(String), die das längste Teilwort der übergebenen
Zeichenkette liefert, in dem alle Zeichen gleich sind. Gibt es mehrere solche Teilwörter, die gleich
lang sind, soll die Methode das erste davon liefern.

Bei der Definition ist "aaa" nicht das Ergebnis bei "aabcdddeffaaacee". Das erste Teilwort der Länge 3 ist "ddd".

Und Du solltest versuchen möglichst exakt zu sein bei der Beschreibung, was Du machst.

Ich gebe mal einen Anfang vor:
- Ich nehme das erste Zeichen und merke es mir mit Zähler = 1. Teilstring = Zeichen. Rest ist Zeichenkette ohne erstes Zeichen.
- Solange das nächste Zeichen gleich dem gemerkten Zeichen ist, gehe ich ein Zeichen weiter und erhöhe den Zähler um 1, hänge da Zeichen an den Teilstring und entferne das erste Zeichen vom Rest.
- Ist das nächste Zeichen nicht gleich dem gemerkten Zeichen habe ich einen Teilstring mit der Länge vom Zähler gefunden.

Ausführung sähe also dann auf einem Zettel so aus:
-> "aabcdddeffaaacee" ist der Anfang. Das erste Zeichen nehme ich und merke es mir: gemerkt = 'a'; Zähler = 1; Teilstring = "a", Rest: "abcdddeffaaacee"
-> nächstes zeichen ist 'a' also: gemerkt='a'; Zähler = 2; Teilstring= "aa"; Rest="bcdddeffaaacee"
-> nächstes Zeichen ist 'b', also: Teilstring "aa" mit Länge 2 gefunden!

Wie geht es weiter? Was muss man denn weiter machen?

 

[parrot]

Bei der Definition ist "aaa" nicht das Ergebnis bei "aabcdddeffaaacee". Das erste Teilwort der Länge 3 ist "ddd".

Und Du solltest versuchen möglichst exakt zu sein bei der Beschreibung, was Du machst.

Ich gebe mal einen Anfang vor:
- Ich nehme das erste Zeichen und merke es mir mit Zähler = 1. Teilstring = Zeichen. Rest ist Zeichenkette ohne erstes Zeichen.
- Solange das nächste Zeichen gleich dem gemerkten Zeichen ist, gehe ich ein Zeichen weiter und erhöhe den Zähler um 1, hänge da Zeichen an den Teilstring und entferne das erste Zeichen vom Rest.
- Ist das nächste Zeichen nicht gleich dem gemerkten Zeichen habe ich einen Teilstring mit der Länge vom Zähler gefunden.

Ausführung sähe also dann auf einem Zettel so aus:
-> "aabcdddeffaaacee" ist der Anfang. Das erste Zeichen nehme ich und merke es mir: gemerkt = 'a'; Zähler = 1; Teilstring = "a", Rest: "abcdddeffaaacee"
-> nächstes zeichen ist 'a' also: gemerkt='a'; Zähler = 2; Teilstring= "aa"; Rest="bcdddeffaaacee"
-> nächstes Zeichen ist 'b', also: Teilstring "aa" mit Länge 2 gefunden!

Wie geht es weiter? Was muss man denn weiter machen?

-> Teilstring "aa" und länge 2 merken und mit dem nächsten Zeichen "b" vom Anfang wiederholen.

 

[parrot]

-> Teilstring "aa" und länge 2 merken und mit dem nächsten Zeichen "b" vom Anfang wiederholen.

-> also und so weiter bis Ende des gegebenen Wort. Und schließlich das gemerkte Zeichen mit der größten Länge zurückgeben.

 

[kneitzel]

-> also und so weiter bis Ende des gegebenen Wort. Und schließlich das gemerkte Zeichen mit der größten Länge zurückgeben.

Wie willst Du den das gemerkte Zeichen mit der größten Länge zurückgeben? Was genau musst Du machen? Was musst Du dir denn dann merken und immer machen?

 

[parrot]

mit einer While schleife?

 

[kneitzel]

While schleife ist eine Implementierung. Derzeit implementieren wir nichts. Wir wollen erst einmal eine umgangssprachliche Lösung....

Dazu kann ich Dir nur empfehlen sehr genau das Beispiel auf einem Zettel durchzuspielen....
Du willst die Schritte, die ich für die ersten "a" gemacht habe, erneut durchführen: Dann kommst Du auf "b" als Teilstring und Rest "cdddeffaaacee"
Was ist denn da dann evtl. wichtig? Machst Du da irgendwas? Hast Du Dir irgendwas aufgeschrieben / gemerkt?
(Wichtige Regel: DU merkst Dir gar nichts. Wenn Du etwas gemerkt haben willst, dann musst du dafür auf dem Zettel einen Platz markieren und da etwas aufschreiben. Das kannst Du dann auch später durchstreichen und was anderes dafür hinschreiben. Aber Du selbst spielst ganz dummes Mäuschen, das nur auf einem Zettel mit einem Stift etwas schmieren kann und nur ganz einfache Dinge auf dem Zettel vergleichen kann ....)

 

[parrot]

gemerkt

Zähler

Teilstring

Rest

'a' 2 "aa" "bcdddeffaaacee"
'b' 1 "b" "cdddeffaaacee"
'c' 1 "c" "dddeffaaacee"
'd' 3 "ddd" "effaaacee"
'e' 1 "e" "ffaaacee"
'f' 2 "ff" "aaacee"
'a' 3 "aaa" "cee"
'c' 1 "c" "ee"
'e' 2 "ee" ""

Wie ich es verstehe, muss ich mir die erste 3 mit "ddd" merken und zurückgeben.

 

[kneitzel]

Was dich doch interessiert ist der größte Teilstring.

Also solltest Du den größten Teilstring, den Du bisher gefunden hast, merken. Und immer wenn Du einen neuen Teilstring hast prüfen, ob dieser größer ist ....

Wie klingt das?

 

[parrot]

Was dich doch interessiert ist der größte Teilstring.

Also solltest Du den größten Teilstring, den Du bisher gefunden hast, merken. Und immer wenn Du einen neuen Teilstring hast prüfen, ob dieser größer ist ....

Wie klingt das?

ja genau. so habe ich auch verstanden. Es klingt nach rekursion.

 

[kneitzel]

Rekursion ist eine Möglichkeit. Das muss aber nicht sein. Bei der Umsetzung ist es so, dass eine Rekursion immer in eine iterative Lösung umgewandelt werden kann. So ist hier eine While Schleife denkbar, die so lange läuft, wie in dem Rest-String noch Zeichen enthalten sind.
Oder wenn man die gegebene Zeichenkette nimmt und in ein Array von Zeichen umwandelt, dann wäre eine einfache Schleife über dieses Array denkbar.
Daher: die konkrete Umsetzung ist da noch nicht festgelegt.

 

[parrot]

ich würde gerne ohne Array umsetzen. Also mit while Schleife und for Schleife

 

[kneitzel]

Dann lass uns die Überlegungen doch erst einmal umformulieren, so dass du eine Schleife sehen kannst.
Kannst du die Überlegungen so umschreiben, dass du einfach vom ersten Buchstaben bis zum letzten durchgehst und dann die Lösung hast?

 

[parrot]

Dann lass uns die Überlegungen doch erst einmal umformulieren, so dass du eine Schleife sehen kannst.
Kannst du die Überlegungen so umschreiben, dass du einfach vom ersten Buchstaben bis zum letzten durchgehst und dann die Lösung hast?

ehrlich gesagt nicht

 

[kneitzel]

Du jetzt nur überlegen, was Du machen würdest, wenn Du die Zeichenkette durchgehst:

- Initialisierung: Du bist beim ersten Zeichen, das erste Zeichen schreibst Du auf deinen Zettel bei "gemerktes Zeichen: ", bei "Zähler: " schreibst Du 1.
Dann gehen wir in die Schleife:
- Du gehst zum nächsten Zeichen.
--> Was machst/prüfst Du? Was machst Du wenn die Prüfung positiv ist? Was machst Du wenn die Prüfung negativ ist?

 

[parrot]

Du jetzt nur überlegen, was Du machen würdest, wenn Du die Zeichenkette durchgehst:

- Initialisierung: Du bist beim ersten Zeichen, das erste Zeichen schreibst Du auf deinen Zettel bei "gemerktes Zeichen: ", bei "Zähler: " schreibst Du 1.
Dann gehen wir in die Schleife:
- Du gehst zum nächsten Zeichen.
--> Was machst/prüfst Du? Was machst Du wenn die Prüfung positiv ist? Was machst Du wenn die Prüfung negativ ist?

Was machst Du wenn die Prüfung positiv ist? : Zähler = Zähler+1;
Was machst Du wenn die Prüfung negativ ist? : gehe ich weiter mit dem nächsten Zeichen.

 

[kneitzel]

Was machst Du wenn die Prüfung positiv ist? : Zähler = Zähler+1;

Ja, das ist ok aus meiner Sicht.

Was machst Du wenn die Prüfung negativ ist? : gehe ich weiter mit dem nächsten Zeichen.

Das ist zu ungenau.
Du bist also über die ersten zwei a drüber und weisst, dass du nun das b hast.
a) Musst Du irgendwas machen/prüfen bezüglich der "aa" / 2 a, was auch immer.
b) wie geht es mit dem b weiter? Du hast ja auf Deiner Seite stehen: gemerktes Zeichen: a, Zähler: 2 - bleibt das alles?

Und das mit dem nächsten Zeichen weiter machen muss ja am Ende so oder so kommen. Das gehört in der Regel mit zu einer Schleife.

 

[parrot]

Musst Du irgendwas machen/prüfen bezüglich der "aa" / 2 a, was auch immer.

ich muss das merken. Also die Länge und das "aa"

 

[parrot]

b) wie geht es mit dem b weiter? Du hast ja auf Deiner Seite stehen: gemerktes Zeichen: a, Zähler: 2 - bleibt das alles?

wenn das letzte Zeichen != das nächste Zeichen ist, gehe ich weiter.

 

[kneitzel]

Nun versuch es zu verallgemeinern: Wann musst dir was merken?
- Du hast erst "aa", dann kommt "b", "c", "ddd", .... Wann merkst Du Dir was? Musst Du Dir alles merken? Oder nur bei bestimmten Kriterien?
- und du gehst einfach weiter, wenn das Zeichen ein anderes ist? Der Zähler und das gemerkte Zeichen bleiben so wie sie sind?

 

[parrot]

Du hast erst "aa", dann kommt "b", "c", "ddd", .... Wann merkst Du Dir was? Musst Du Dir alles merken? Oder nur bei bestimmten Kriterien?

ich glaube, dass ich alles merken muss bis ende.

 

[parrot]

und du gehst einfach weiter, wenn das Zeichen ein anderes ist? Der Zähler und das gemerkte Zeichen bleiben so wie sie sind?

ja die bleiben wie sie sind weil nach dem Durchlauf wird noch vergleichen.

 

[kneitzel]

Also wenn einen nur der längste (bzw. bei gleich langen Elementen das erste Vorkommen) interessiert, dann musst Du alle speichern?
Und bei der Stelle mit dem aktuellen Zeichen und dem Zähler: Was machen wir da? Wir ermitteln doch lediglich den aktuellen Teilstring...

 

[parrot]

Also wenn einen nur der längste (bzw. bei gleich langen Elementen das erste Vorkommen) interessiert, dann musst Du alle speichern?
Und bei der Stelle mit dem aktuellen Zeichen und dem Zähler: Was machen wir da? Wir ermitteln doch lediglich den aktuellen Teilstring...

dann muss man nicht alle speichern. Einfach löschen und weiter

 

[parrot]

String max = " ";
int i = 0;
while (i < s.length()) {

int j = i + 1;

while (j < s.length() && s.charAt(i) == s.charAt(j)) {

j++;
}

if(j - i > max.length()) {

max = s.substring(i, j);
}

}
return max;
}

 

[Xyz1]

Ich habe es auch mal probiert - man muss nur etwas "um die Ecke denken":

Spoiler

	public static String gibLaengstesKonstantesStueck(String string) {
		String r = "";
		char[] a = string.toCharArray();
		for (int i = 0; i < a.length; i++) {
			for (int j = i + 1; j <= a.length; j++) {
				if (j == a.length || a[i] != a[j]) {
					if (j - i > r.length()) {
						r = string.substring(i, j);
					}
					break;
				}
			}

		}
		return r;
	}

	// TEST
	public static void main(String[] args) {
		char[] aa = new char[20];
		for (int i = 0; i < 10; i++) {
			for (int j = 0; j < aa.length; j++) {
				aa[j] = (char) ('a' + (int) (Math.random() * 6));
			}
			String string = new String(aa);
			System.out.println(aa);
			System.out.println(gibLaengstesKonstantesStueck(string));
			System.out.println();
		}
		System.out.println(gibLaengstesKonstantesStueck("aaaa"));
		System.out.println(gibLaengstesKonstantesStueck("aabcdddeffaaacee"));
	}

 

[kneitzel]

String max = " ";
int i = 0;
while (i < s.length()) {

int j = i + 1;

while (j < s.length() && s.charAt(i) == s.charAt(j)) {

j++;
}

if(j - i > max.length()) {

max = s.substring(i, j);
}

}
return max;
}

Ja, die Lösung ist recht schön, aber probier einmal eine Eingabe "abcdef" -> da müsste "a" rauskommen. Das dürfte bei Dir derzeit aber nicht Fall sein.

Was bei Dir und @Tobias-nrw auffällt: Ihr findet Substrings mehrfach. Daher wäre meine Lösung etwas wie:

public class FindLongestSubstring {

    public static void main(String[] args) {
        System.out.println(getLongestSubstring("abcdefg"));
        System.out.println(getLongestSubstring("aabbcddddefg"));
    }

    public static String getLongestSubstring(final String source) {
        String result="";

        int currentIndex = 0;
        char currentChar = 0;
        int currentCharCount = 0;
        while (currentIndex < source.length()) {
            if (currentChar != source.charAt(currentIndex)) {
                if (currentCharCount > result.length()) {
                    result = source.substring(currentIndex - currentCharCount, currentIndex);
                }
                currentChar = source.charAt(currentIndex);
                currentCharCount = 0;
            }

            currentCharCount++;
            currentIndex++;
        }
        return result;
    }
}

Man geht alle Zeichen der Reihe nach durch, ist es nicht das gemerkte Zeichen, dann wird
a) geprüft, ob der Zähler größer ist als das bisher gemerkte Ergebnis um ggf. das Ergebnis auszutauschen.
b) das gemerkte Zeichen wird gesetzt und der Zähler wird auf 0 gesetzt.
Es wird das aktuelle Zeichen gezählt und zum nächsten Zeichen gegangen.

Das wäre auch der Pseudocode gewesen, auf den ich Dich etwas führen wollte. Es braucht keine innere Schleife oder so. Wenn man es auf dem Papier durchspielt, dann macht man das doch auch nicht.
Wenn ich "aaaa" vorgebe, dann zählst Du ja nicht die a vm ersten an: 4, ok, merke mit "aaaa".
Und dann zählst Du vom 2. a an: 3. - 3 ist aber kleiner als 4 ...

Daher generell mein Vorschlag, so Dinge vernünftig auf einem Zettel durchzuspielen. Dann kommt man in der Regel zu einfachen Lösungen.

 

[Xyz1]

Das spielt keine Rolle. Um Micro-Optimierung sollte es hier nicht gehen, sondern um Einfachheit und Lesbarkeit.

Btw. Hast Du Deins mit "aaaa" mal getestet? Also mit einem String der nur gleiche Zeichen enthält?

 

[kneitzel]

Eine Micro-Optimierung wäre es nur, wenn man erst eine andere Lösung schreiben würde um diese dann zu optimieren.

Hier geht es um eine geradelinige Umsetzung, also schlichtes überlegen, wie ist vorzugehen und was bedeutet dies.
Einfacher lesbar ist eine Frage der Sichtweise - also zwei Schleifen vs. eine Schleife - da würde zumindest ich die erste Schleife bevorzugen. Besonders nach dem Aufwand, das ja eigentlich als Pseudocode so vorzubereiten (Da wurden halt die Teilstrings nur einmal genommen und nicht mehrfach unterteilt).

Und ja - da habe ich tatsächlich einen kleinen Fehler: der letzte Substring wird nicht verarbeitet.
Das kann man entweder nach der for Schleife berücksichtigen:

        if (currentCharCount > result.length()) {
            result = source.substring(source.length() - currentCharCount);
        }

Oder man macht das direkt nach dem hochzählen und schreibt dann das result halt n-fach bei einem Ergebnis der Länge n:

public class FindLongestSubstring {

    public static void main(String[] args) {
        System.out.println(getLongestSubstring("abcdefg"));
        System.out.println(getLongestSubstring("aabbcddddefg"));
        System.out.println(getLongestSubstring("aaaaa"));
    }

    public static String getLongestSubstring(final String source) {
        String result="";

        int currentIndex = 0;
        char currentChar = 0;
        int currentCharCount = 0;
        while (currentIndex < source.length()) {
            if (currentChar != source.charAt(currentIndex)) {
                currentChar = source.charAt(currentIndex);
                currentCharCount = 0;
            }

            currentCharCount++;
            currentIndex++;
            if (currentCharCount > result.length()) {
                result = source.substring(currentIndex - currentCharCount, currentIndex);
            }
        }
        return result;
    }
}

Letzteres ist halt einfach nur eine Schleife um einmal durch den String zu gehen und man hat einfach nur ein aktuellen Bearbeitungspunkt im String, ein gemerktes Zeichen und eine gemerkte Anzahl.

 

[Xyz1]

Ich find meins schöner. @mihe7 Was sagst Du dazu?

 

[kneitzel]

Och nee ... da hast Du was angestellt .... der haut uns jetzt eine Streaming-Lösung um die Ohren und beschimpft uns beide als Anfänger

 

[parrot]

public static String giblaengsteKonstesStueck (String s) {

String max = " ";
int i = 0;
while (i < s.length()) {

int j = i + 1;

while (j < s.length() && s.charAt(i) == s.charAt(j)) {

j++;
}
if (j - i > max.length()) {

max = s.substring(i, j);
}
i = j;
}
return max;
}