# Rekursives Umdrehen, Spiegeln. etc. von Strings



## Siebenkern (6. Dez 2013)

Moin,

ich wende mich mal mit einem (wahrscheinlich völlig lächerlichen) Problem an euch.
und zwar muss ich für die Uni mit rekursiven Methoden einzelne Strings spiegeln bzw. umdrehen.
Die Programme, dei dafür erforderlich sind, sollten sich ja nicht allzusehr voneinander unterscheiden, da die Ausgabe beim Spiegeln Mit dem eingegebenen String("ApfellefpA"), beim Umdrehen Ohne den eingegeben String (lefpA) wiedergegeben wird. Ich dachte mir deshalb, dass ich einfach die Länge des Strings bestimme und dann beim letzten Buchstaben beginne. Aber irgendwas geht schief.

vielleicht könnt ihr mir ja helfen 


```
public class aufgabe12fuenf {
	
	/**
	 * 
	 * @param s 		umzudrehender String
	 * @param ausgabe 	string, der gefüllt wird.
	 * @param zaehler	Länge des Strings
	 * @return			fertiger String
	 */
	
	static String backward(String s, String ausgabe, int zaehler){
		int x = zaehler;
		if (s.length() == 0) return "";
		if (s.length() == 1) return s;
		
		ausgabe += s.charAt(x);
		x -= 1;
		return ausgabe + backward(s, ausgabe, x);
	}
	/**
	 * 
	 * @param s 	zu drehender String;
	 * @return		ruft überladene Methode backward auf
	 */
	static String backward(String s){
		int y = s.length() - 1;
		return backward(s, "", y);
	}
	
	public static void main (String[]args){
		
		System.out.println(backward("olleH"));
	}

}
```


----------



## PublicClass (7. Dez 2013)

Hi Siebenkern,

Ich bin noch ein Anfänger, aber ich hatte folgende Idee zu deinem Problem:

Bestimm die länge des Strings mit .length
und lass dann anhand des Index die Zeichen nacheinander ausgeben.
Ich denke mal das sich dafür eine ordentliche Methode schreiben lässt die universell anwendbar ist.

Das wäre mein Idee würde dir gerne ein Beispiel geben aber habe zur zeit ein wenig Stress also sorry.
Und wahrscheinlich geht das auch noch irwie viel einfacher aber wie gesagt bin ein Anfänger 
und ganz wahrscheinlich ist das auch großer quatsch was ich da geschrieben hab 
LG und Vllt konnte ich ja sogar helfen.


----------



## Salohcin (7. Dez 2013)

PublicClass hat gesagt.:


> Hi Siebenkern,
> 
> Ich bin noch ein Anfänger, aber ich hatte folgende Idee zu deinem Problem:
> 
> ...



Hallo!
Es geht hier explizit um Rekursion, in der Modellierung, siehe Wikipedia Artikel zu Rekursion!


Nun zum Fehler, zuerst "int y = s.length() -1;" muss "int y = s.length();" sein.  Der Fehler ist das duu den case von "zähler == 0" nicht abfängst und der Alghorythmus einmal zuviel in backward(); aufruft...

Also hier ist der funktionierende Quellcode, da in Eile:

```
public class aufgabe12fuenf {
  
  /**
  *
  * @param s         umzudrehender String
  * @param ausgabe   string, der gefüllt wird.
  * @param zaehler   Länge des Strings
  * @return          fertiger String
  */
  
  static String backward(String s, String ausgabe, int zaehler){
    int x = zaehler;
    if (s.length() == 0) return "";
    if (s.length() == 1) return s;
    
    x --;
    
    System.out.println(s.charAt(x));//hier nochmal zur verdeutlichung, wann was ausgelesen wird

    if (x==0) {//fäng x == 0 ab, damit nicht nochmal in backward eintritt, da kam der error her ;)
      return "" + s.charAt(x);
    } // end of if
    
    return s.charAt(x) + backward(s, ausgabe, x);
  }
  /**
  *
  * @param s     zu drehender String;
  * @return      ruft überladene Methode backward auf
  */
  static String backward(String s){
    int y = s.length(); // kein -1
    return backward(s, "", y);
  }
  
  public static void main (String[]args){
    System.out.println("olleH".charAt(1));
    
    System.out.println(backward("olleH"));
  }
  
}
```
MfG Salohcin [Q1]


----------



## DrZoidberg (7. Dez 2013)

Es gibt da verschiedene Möglichkeiten das zu schreiben.

z.B. so


```
static String backward(String s, String ausgabe, int zaehler){
    if(zaehler >= 0) {
        return backward(s, ausgabe + s.charAt(zaehler), zaehler-1);
    } else {
        return ausgabe;
    }
}

static String backward(String s){
    if (s.length() < 2) return s;
    return backward(s, "", s.length() - 1);
}
```

oder so


```
static String backward(String s) {
    if(s.length() < 2) return s;
    else return backward2(s.substring(1))+s.charAt(0);
}
```


----------

