# Wiederholte Strings



## Lordddodon (6. Dez 2009)

Hey Leute,

also ich hab eine Aufgabe die sich mit Strings beschäftigt und habe jetzt mit 2 Methoden eiin paar probleme 
Aufgabenstellung:
"
Definieren Sie eine veränderliche Klasse RepString, ¤ die einen String repräsentiert, der aus einem
mehrfach wiederholten Wort besteht. Die Bestandteile eines RepString-Objektes sind das Wort (word) und
der nicht-negative Wiederholungs-Zähler (count). Ein Beispiel: Wenn das Wort "ja" viermal wiederholt
wird, entsteht der Repstring 4×"ja", ausgeschrieben "jajajaja".
Die ausgeschriebene Form ist nicht eindeutig! "jajajaja" kann der Repstring 4×"ja" sein, aber auch
2×"jaja" oder 1×"jajajaja".
"

1. normalize
      Maximiert den Zähler dieses Repstrings. Wenn das Wort leer ist, geschieht nichts. Liefert
      diesen Repstring zurück.
Zu dieser Methode hab ich leider keinen Plan wie ich diese verwircklichen soll für einen Denkanstoß wäre ich sehr dankbar ...

2.less
     stellt fest, ob this ein echtes Präfix ¤ von eines weiteren Repstrings ist. Der Vergleich bezieht
     sich auf die ausgeschriebene Form.
Diese Methode hab e ich bereits  geschrieben funtzt aber nicht 


```
public class RepString
{

    private int count;
    private String word;

    private String z= "\"";

 public RepString(int a, String s)
 {
   count = a;
   word  = s;
   if(this.word.equals(""))
           throw new IllegalArgumentException("null word");
 }

 public RepString(String s, int a)
 {
    word = s;
    count = a;
    if(this.word.equals(""))
           throw new IllegalArgumentException("null word");
 }


 private void setCount(int a)
 {
     a = count;
 }

 private void setWord(String a)
 {
     a = word;
 }
 
 public int getCount()
 {
     return count;
 }

 public String getWord()
 {
     return word;
 }

 private String give(RepString a)   //Alternative Ausgabe für RepString
 {                                  //4x"ja"
    return a.count+"x"+z+a.word+z;
 }

 public boolean equals(RepString r)
 {
     String a= this.myString();
     String b= r.myString();

     return this.myString().equals(r.myString());
        
 }
private String myString()
{
     String x="";
     int s = 0;
    while (s<this.count)
    {

        x += this.word;
        s++;
    }
    return x;
 }

 public String toString()
 {
     String x ="";
     int s = 0;
    while (s<this.count)
    {

        x += this.word;
        s++;
    }
    return x;
 }

 public String copy(RepString r)
 {
     this.count=r.count;
     this.word=r.word;
     return give(new RepString(r.count,r.word));

 }

// public String normalize()
// {
//
// }

 public RepString add(int a)
 {

   int d = a + this.getCount();

   if (d < 0)
       setCount(0);

   
   return new RepString(d,this.word);
 }


 public RepString add(String a)
 {

   String e = getWord() + a ;

   return new RepString(this.count,e);
 }
 

 public RepString add(RepString a)
 {
     String e = a.word+ this.getWord();
     int f = a.count+ this.getCount();

     return new RepString(f,e);
 }

 public boolean less(RepString r)
 {
     String c= this.toString();
     String b= r.toString();
     int f = c.indexOf(b);
     if (f<0)
         return false;
     else 
         return true;
 }


}
```

Danke schon mal ^^


----------



## Marco13 (6. Dez 2009)

Ja, die Methode 
public boolean less(RepString r)
prüft bei dir im Moment nicht, ob "this" ein präfix von r ist, sondern ob r in this enthalten ist...


----------



## Lordddodon (6. Dez 2009)

Also hab  die Methode umgeschieben 


```
public boolean less(RepString r)
 {
     
     return this.toString().startsWith(r.toString());
 }
```

diese scheint auch so zu arbeiten wie sie soll nur wenn ich folgendes teste 



```
RepString a = new RepString("ja",4);
        RepString b = new RepString("jaja",2);
        
        System.out.println(b.less(a.add(1))); // kommt true raus stimmt auch 
        System.out.println(a.less(a.add(1))); // kommt auch true raus sollte aber false sein
```

Problem hatm sich erledigt der abgabe server schluckt die methode nur normalize fehlt etz noch ...

wäre echt super wenn mir jemand nen tipp geben könnte


----------



## Dozor (8. Dez 2009)

Also so Versteh ich derzeit die Methode normalize()
Beispiel:
du hast den RepString 1x "jajajaja" nun wendest du die normalize()-Methode die sich selbst wiederum recursiv aufruft
So passiert dann beim ersten aufruf der normalize()-Methode spalten des Strings in der mitte und vergleichen der ersten hälfte mit der zweiten wenn Sie übereinstimmen erzeugen eines neuen RepStrings mit den Werten 2x"jaja" und wieder normalize() aufrufen.

Das Problem was ich da sehe ist wie man das bei ungleichen wiederhohlungen prüfen könnte denn das obere Beispiel funktioniert nicht wenn der aller erste RepString 1x"jajaja" ist und das ergebnis nach normalize ein RepString mit 3x"ja" sein sollte.

Hoffe das war denk anstoß genug wenn nicht ich denk nochmal drüber nach. 

Gruß
Dozor


----------



## Marco13 (8. Dez 2009)

Noch ein Anstoß für den Fall der ungeraden Wiederholungen - relativ einfach wäre, einen Sting aus dem Anfang des RepStrings zu bilden, und diesen Anfangsteil so lange zu verlängern, bis der Rest nur eine Wiederholung des Anfangsteils ist - im Pseudocode sowas wie

```
// Gibt "true" zurück, wenn "rest" durch mehrfaches Aneinanderhängen von "segment" entsteht
boolean istWiederholungVon(String segment, String rest) {...}

String zuNormalisieren = ...
int ende = 2;
while (true)
{
    String anfang = zuNormalisieren.substring(0,ende);
    String rest= zuNormalisieren.substring(ende-1,zuNormalisieren.length());
    if (istWiederholungVon(anfang, rest)) break;
}
```
Man könnte in der istWiederholungVon-Methode auch gleich zählen, wie viele Wiederholungen es sind, und diese Zahl dann zurückzugeben (bzw. 0 wenn es nicht passt). 

Aber insgesamt ist das wohl ziemlich ineffizient, deswegen solltest du das besser nur versuchen, wenn dir absolut nichts anderes einfällt.

Was Dozor vorgeschlagen hat ist natürlich 1000x geschickter, ... aber eben nicht allgemein anwendbar.

Aber wenn man ein bißchen überlegt, findet man bestimmt auch für den allgemeinen Fall eine schönere Lösung


----------



## Dozor (9. Dez 2009)

Aufgrund von Marcos anregung habe ich noch bissl drüber nachgedacht und bin der Meinung das ich eine vernünftige Lösung für beide Fälle nun habe... der code schwirrt mir schon im Kopf herum.

Wie Versprochen auf anregung von Marcos würde ich es so lösen, habe mir die Freiheit genommen die equals-Methode anzupassen.

Habe zur besseren nachvollzierbarkeit die Sysouts drin gelassen.

```
public RepString normalize() {
		RepString result = null;
		int count = 0, subLength = 1;
		String subWord = this.word.substring(0, subLength);
		System.out.println(subWord);
		boolean end = true;
		while (end) {
			count = 0;
			subWord = this.word.substring(0, subLength);
			String[] splited = splitByLength(subLength);
			for (int j = 0; j < splited.length; j++) {
				if (!subWord.equals(splited[j])) {
					subLength = (subLength * j) + 1;
					end = true;
					break;
				} else {
					count++;
					end = false;
				}
			}
			System.out.println(count);
		}
		result = new RepString(count, subWord);
		if (result.equals(this)) {
			return this;
		} else {
			return result;
		}
	}

	public String[] splitByLength(int length) {
		int anzahl = (int)Math.ceil(this.word.length() / (double)length);
		System.out.println("Anzahl: "+anzahl);
		String[] words = new String[anzahl];
		int start = 0, end = length;
		for (int i = 0; i < words.length; i++) {
			end = (length * i) + length;
			if (end > this.word.length()) {
				end = this.word.length();
			}
			words[i] = this.word.substring(start, end);
			start += length;
			System.out.println(words[i]);
		}
		return words;
	}

	public boolean equals(RepString r) {
		return (r != null && r.getCount()== this.getCount() && r.getWord().equals(this.getWord()));
	}
```

Falls du Fragen hast sag bescheid, ich versuch es gern zu erklären.


----------

