Gleiche Buchstaben Aufage

parrot

Aktives Mitglied
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.
 
K

kneitzel

Gast
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

Top Contributor
Hallo Leute ich weiß nicht wie ich anfangen kann.

Ich helfe dir mal mit dem Anfang
Java:
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

Aktives Mitglied
Ich helfe dir mal mit dem Anfang
Java:
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

Aktives Mitglied
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.
 
K

kneitzel

Gast
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

Aktives Mitglied
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.
 
K

kneitzel

Gast
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

Aktives Mitglied
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.
 
K

kneitzel

Gast
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

Aktives Mitglied
gemerktZählerTeilstringRest
'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.
 
K

kneitzel

Gast
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?
 
K

kneitzel

Gast
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.
 
K

kneitzel

Gast
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?
 
K

kneitzel

Gast
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

Aktives Mitglied
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.
 
K

kneitzel

Gast
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.
 
K

kneitzel

Gast
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?
 
K

kneitzel

Gast
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

Aktives Mitglied
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

Aktives Mitglied
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;
}
 
X

Xyz1

Gast
Ich habe es auch mal probiert - man muss nur etwas "um die Ecke denken":
Java:
	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"));
	}
 
K

kneitzel

Gast
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:
Java:
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.
 
X

Xyz1

Gast
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?
 
K

kneitzel

Gast
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:
Java:
        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:
Java:
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.
 
K

kneitzel

Gast
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

Aktives Mitglied
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;
}
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
bueseb84 Gleiche Maven Versions in Child Modulen Allgemeine Java-Themen 13
M ZipOutputStream gleiche Datei andere Größe? Allgemeine Java-Themen 0
T Gleiche Operation dauert teilweise sehr lange Allgemeine Java-Themen 12
R Gleiche Objektreferenz trotz clone()? Allgemeine Java-Themen 12
turmaline OOP zwei gleiche Methoden mit kleinen Unterschieden Allgemeine Java-Themen 15
G Gleiche Packages in verschiedenen JAR Dateien - Welches Package wird verwendet? Allgemeine Java-Themen 5
M HashSet<String> das selbe oder das gleiche? Allgemeine Java-Themen 4
J Gleiche Packagestruktur in zwei *.jar Dateien Allgemeine Java-Themen 4
M Die gleiche Klasse in mehreren JAR files Allgemeine Java-Themen 5
B Liste auf gleiche Elemente untersuchen? Allgemeine Java-Themen 2
V String formatiert ausgeben ( gleiche Anzahl von Ziffern ) Allgemeine Java-Themen 5
E ArrayList referenziert immer auf das gleiche Objekt Allgemeine Java-Themen 2
kodela Gemittelte Ausgabe von Buchstaben Allgemeine Java-Themen 10
W Russische UND lateinische Buchstaben Allgemeine Java-Themen 19
Kingamadeus2000 Alle mehrfach vorkommenden Buchstaben rekursiv aus einem String entfernen. Allgemeine Java-Themen 6
F In String 2 Buchstaben vertauschen Allgemeine Java-Themen 2
F Zurnung nach Buchstaben und deren Prüfung Allgemeine Java-Themen 9
Tacofan Hangman so viele Labels wie Buchstaben Allgemeine Java-Themen 5
L Menge der Buchstaben eines Textes zählen Allgemeine Java-Themen 3
KaffeeFan Methoden replace alle Buchstaben Allgemeine Java-Themen 3
P Methoden Häufigkeistverteilung von Buchstaben Allgemeine Java-Themen 2
I Eclipse API zur Buchstaben/Zeichensatzumwandlung Allgemeine Java-Themen 1
L Suchvorschläge beim eingeben einzelner Buchstaben Allgemeine Java-Themen 3
J Doppelte Buchstaben löschen - letztes Wort macht er nicht Allgemeine Java-Themen 2
S Char-index aller Buchstaben..? Allgemeine Java-Themen 3
S Entfernen von allen Nicht-Buchstaben chars aus einem String ohne Regex..? Allgemeine Java-Themen 10
C Buchstaben, die in zwei Wörtern vorkommen Allgemeine Java-Themen 13
P Unicode-Problem: Griechische Buchstaben Allgemeine Java-Themen 11
T Logische Abfolge von buchstaben kombinationen Allgemeine Java-Themen 12
G Buchstaben in umkekehrter Reihenfolge ausgeben Allgemeine Java-Themen 4
A Wort in seine Buchstaben zerlegen Allgemeine Java-Themen 37
S Methode zum Zählen von Buchstaben in Strings gesucht Allgemeine Java-Themen 11
E Spezielle Buchstaben darstellen? Allgemeine Java-Themen 7
J Java - 4-Buchstaben-Programm. Hilfe. ich hänge fest Allgemeine Java-Themen 7
Luma Buchstaben "umrechnen" in HEX-, DEC- und BIN-Forma Allgemeine Java-Themen 2
G Methode, die Buchstaben in Zahlen umwandelt? Allgemeine Java-Themen 13
Luma String in seine Buchstaben zerlegen? Allgemeine Java-Themen 3
M Buchstaben anordnen / Wortliste Allgemeine Java-Themen 2
I Suche Methode: Buchstaben in ASCII umwandelt Allgemeine Java-Themen 2
H Kann keine Zahlen von Buchstaben unterscheiden Allgemeine Java-Themen 4
A Buchstaben zählen Allgemeine Java-Themen 5

Ähnliche Java Themen

Neue Themen


Oben