String umdrehen

starbug

Erfahrenes Mitglied
Hallo,

habe folgendes Problem. Ich soll in einer Aufgabe eine rekursive Methode schreiben, die einen String entgegen nimmt und ihn dann umgekehrt wieder ausgibt. Es gilt außerdem noch, das man nur den +-Operator auf Strings sowei die beiden Methoden charAt() und length() verwenden darf. Hier ist mal mein Code:

Code:
public class StringRekursion {
    
   public static void ausgeben(String st)
{
int length = st.length();
if (length > 0)
{
    //System.out.print(st.charAt(0));
    ausgeben (st.substring(1, length));
   System.out.print(st.charAt(0));
}
}

   public static void main(String args[])
   {
   
     StringRekursion str = new StringRekursion();
     str.ausgeben("Hallo");
     
     
   }
}

Wie ihr seht habe ich hier noch die substring()-Methode eingebaut, da ich nicht weiss wie ich das anders lösen soll. Kann mir jemand helfen?
 
Du verwendest eine rekursive Methode. Nur wenn du das schon so machst, dann frag ich mich, warum du anstatt den String von hinten nach vorn auszugeben lieber den String solange von vorne abschneidest, bis du den String auf 0 gekürzt hast. Lass den String doch von hinten nach vorne ausgeben, dann brauchst du auch kein substring().

EDIT:
So als Tipp: Du müsstest die Methode etwas abändern, und zwar brauchst du noch einen Parameter (pos) für die Position des "Zeigers". Beim ersten Aufruf ist pos = length-1 und wird bei jedem Aufruf immer um 1 subtrachiert bis pos == 0 ist.
 
Zuletzt bearbeitet:
Hi,

Ich hätt das auch eher anders gemacht...
Immer den letzten Buchstaben ausgeben und dann davor. Das geht mit Rekursion ja recht einfach.
Kleiner Tipp: Mit Zähler so lange durchlaufen, bis der Zähler am letzten Buchstaben angekommen ist. (So hab ich's zumindest gemacht)

Gruß,
Martin

Edit: Akeshihiro war schneller.
 
Hmm also ich glaube ich habe im Moment einfach ein Brett vorm Kopf. Ich muss der ausgeben-Methode doch den gekürzten String übergeben richtig, aber wenn ich das mit der charAt-Methode versuche bekomme ich ne Fehlermeldung. Danke trotzdem schonmal
 
Nein, du musst keinen gekürzten String übergeben, sondern das Original und einen Zahlenwert für die Position, die der nächste Methoden-Aufruf verwenden soll, um quasi das vorherige Zeichen zu verwenden. Das heißt die Zahl wird immer kleiner.

Hier mal die neue Methodensignatur:
Java:
public static void rueckwertsAusgeben(String str, int pos) {}

Ein Beispielaufruf könnte dann so aussehen:
Java:
String blub = "hallo und so";
rueckwertsAusgeben(blub, blub.length()-1);

So, in rueckwertsAusgeben (oder von mir aus auch einfach ausgeben, falls du das so lassen willst), musst du jetzt einfach das Zeichen an der Position, die die Methode bekommen hat, ausgeben und dann rufst du die Methode ein weiteres Mal auf, aber für die Position übergibst du dann pos-1. Natürlich musst du auch eine Abbruchbedingung haben. Dabei kommt es drauf an, wie du es lieber machen würdest. Ich persönlich prüfer lieber zuerst alle Parameter und wenn was nicht stimmt, dann wird auch nicht forgefahren. In dem Fall hieße das, dass sobal pos == -1 ist, einfach ein return stattfindet. Oder du prüfst vor dem rekursiven Aufruf, ob pos == 0 ist, denn das hieße, dass du bereits das erste Zeichen ausgegeben hast und somit fertig bist. also wenn pos > 0, dann Methode aufrufen, sonst nicht.
 
Danke das ist schon mal ein guter Tipp allerdings befürchte ich das ich die ausgeben-Methode nicht um einen int-Parameter erweitern darf sondern das nur ein String übergeben werden darf aber ich werd mich da am wochenende nochmal umhören :)
 
Warum darfst du das nicht? Ist die so vorgegeben worden?

EDIT:
Wenn die Methode die Signatur haben soll, die du oben gepostet hast und du kein substring() verwenden darfst, dann fällt mir nur eine Möglichkeit ein. Du müsstest dann mit einer Schleife einen temporären String generieren und den dann als Parameter übergeben. Aber ob die Lösung so toll ist, wage ich bezweifeln.
 
Zuletzt bearbeitet:
Ja genau das ist ja mein Problem, es ist so vorgegeben aber wie kann ich einen temporären String realisieren?
 
Hallo,

hast du schon an folgendes gedacht oder wie ist das mit den Konventionen?


Java:
public class MainExample
{
	public static void main(String[] args) 
	{
		String strTemp = "Hallo";
		new MainExample().recursiveMethod(strTemp);
	}
	
	private void recursiveMethod(String str)
	{
		if(str.length() > 1)
		{
			int i = str.length() - 1;
			while(i >= 0)
			{
				this.recursiveMethod(String.valueOf(str.charAt(i)));
				i--;
			}
		}
		else
		{
			System.out.print(str);
		}
	}
}


Viele Grüße...
 
Ich hab mir das mal fix angeschaut
Falls du nur die Methoden verwenden darfst und die Sache mit der If Anweisung auch drin bleiben soll.
Kannst du wie Akeshihiro schon erwähnt hat, beispielsweise eine Klassen Variable anlegen, in der du dir dann die Zeichen des Strings von hinten her merkst, um diese dann am ende auszugeben.
Anschließend rufst du rekursiv die Methode mit einen String der um eines kleiner ist als dein Ursprungs String.
Da du keinen substring verweden darfst leg dir hierfür einfach eine String Variable die du dir mit charAt() zusammensetzt

Schön ist weiß Gott anders aber es funktioniert

Dude
 
Zurück