Rekursiv

[IloveJava]

Hallo hab ein kleines Problem:

Und zwar würde ich gerne eine Zahl umgekehrt ausgeben lassen, aber das mit rekursivem Aufruf und ohne while Schleife.

[JAVA=1] int rev( int z )
{
int u = 0 ;
while ( z > 0 ) {
printf( "z = %10d, u = %10d\n", z, u ) ;
u = 10 * u + z % 10 ;
z /= 10 ;
}
return u ;
}
[/code]

Soweit nicht rekursiv. Aber wie mach ichs jetzt rekursiv und am besten mit if Schleife?

 

[XHelp]

if-schleife.de
Wie sieht denn dein eigener Versuch dazu aus?

 

[IloveJava]

if (z==0)
return u;
else

... so schonmal anfangen xD

Aber da hört der bei mir sofort auf wenn ich bei else dann noch die "Rechnung" hinschreib -.-
Schneidet quasi nur eine Zahl ab und gibt den Mist dann aus.

 

[bygones]

fuer eine Rekursion brauchst du zum einen eine Abbruchbedingung, die hast du schon richtig aufgeschrieben.

zum anderen brauchst du den rekursiven aufruf.

schau dir deine Methode an, die iterative arbeitet mit einem Parameter, intern aendern sich aber zwei, ergo braucht deine rek. Methode z und u als Parameter.

Dann ists einfach, der rek. Aufruf besteht aus den Aenderungen der Variablen die du schon geschrieben hast....

also das gleiche nur etwas anders ;-)

 

[IloveJava]

Das klingt alles so schön einfach bei Dir, ich schau mir gerade die rekursive Methode an aber so richtig schlau werde ich daraus nicht.

Und wenn ich es mit goto mache anstatt mit if?

   if (z==0)
   return u;
   else
   {
   printf( "z = %10d, u = %10d\n", z, u ) ;
   u = 10 * u + z % 10 ;
   z = z/10 ;

So funktioniert es ja nun nicht, da gibt der mir immer nur eine abgeschnittene Zahl aus.

Aber mit goto vielleicht?

So funktioniert es zumindest:

_1:
   if (z==0)
   return u;
   else
   {
   printf( "z = %10d, u = %10d\n", z, u ) ;
   u = 10 * u + z % 10 ;
   z = z/10 ;
   goto _1;
   }

Aber stilistisch bestimmt mies Und ist das überhaupt rekursiv? o.o

 

[AngryDeveloper]

Ne, du brauchst kein GOTO. Das hat mir Rekursion nichts zu tun.
Was dir fehlt, ist einfach noch der Rekursive Aufruf in deinem else-Zweig.
Rekursiv bedeutet, dass die Methode sich selbst aufruft.

 

[IloveJava]

Ja genau, das dachte ich mir doch...
Mal überlegen...

 

[IloveJava]

return rev(z) irgendwie am Ende -.-

aber dann hab ich ja das u wieder auf 0 gesetzt und das will ich ja nicht.

 

[bygones]

du scheinst immer darueber nachzudenken

    int rek(int z, int u) {
        if (z == 0) {
            return u;
        }
        return rek(z / 10, 10 * u + z % 10);
    }

der erste aufruf waere dann zb [c]rek(2345,0)[/c]. Du kannst auch noch eine hilfsmethode dazwischen schalten, wenn dich das stoert

    int rek(int z) {
      return doRek(z, 0);
    }

    int doRek(int z, int u) {
        if (z == 0) {
            return u;
        }
        return rek(z / 10, 10 * u + z % 10);
    }

wie du siehst ist das einzige was sich aendert dass die aenderungen der variablen nun im rekursiven Aufruf stehen

 

[Firephoenix]

Du hast die Zahl 1234 und willst sie rekursiv rückwärts zusammenbauen, wie machst du das?

Als erstes kommt die 4 , allerdings willst du eine 4xxx, also musst du die 4 mit 1000 multiplizieren
Dann kommt die 3, du willst eine 3xx, also muss du die 3 mit 100 multiplizieren
Jetzt kommt die 2, du willst aber eine 2x, also musst du die 2 mit 10 multiplizieren
Jetzt kommt die 1, du willst auch eine 1, also kannst du sie mit 1 multiplizieren

Jetzt addierst du 4000+300+20+1 und hast 4321.

Wie setzt sich das ergebnis also zusammen?

Letzte Zahl * 10^(AnzahlStellen-1) + rückwärts von der restliche zahl ohne die letzte Ziffer.

Wie kommst du bei 1234 auf 4 bzw 123 auf 3 oder bei 1 auf 1?
Nehm die zahl einfach modulo 10.

Für die Anzahl der Stellen kannst du den Logarithmus zur Basis 10 benutzen, das gibt einen double und wenn du den nach int castest anstatt aufzurunden kriegst du bei der 1234 z.b. den wert 3 raus.

die restlichen stellen ohne die letzte Ziffer kriegst du bei einer Integer-Zahl auch leicht, teil sie einfach ohne typecast durch 10.

Der Rekursionsanker ist auch entsprechend leicht. Beim letzten mal rufst du die Funktion mit 1/10 auf, kriegst also eine 0 als aufrufparameter. Wenn du jetzt einfach 0 zurückgibst wird am eine eine 0 addiert und du hast auch den Abbruch geschafft.

Jetzt aus dem ganzen eine schöne Funktion machen und du kannst nur mit arithmetischen Mitteln rekursiv eine Zahl umdrehen.

Gruß

 

[IloveJava]

So hab ichs gerade schonmal getestet da kam bei mir nur null raus o.o

Jetzt muss ich mal gerade den Fehler suchen.

 

[IloveJava]

Okay jetzt hab ich nur ein(e) Problem / Frage:

Ist u dann erstmal sofort 0?
Und wenn ich eine Zahl eingebe ist es ja nur eine Zahl und nicht zwei Zahlen.
Wenn ich dann auf einmal zwei Zahlen in der Funktion hab dann wird der Compiler böse?!

error: too few arguments to function 'rev'|

Weil ich les ja nur eine Zahl ein die umgedreht werden soll. Oder denk ich gerade falsch? o.o


Ahhhh okay hat sich erledigt, ich kann sie ja daaaann einfach 0 setzen Logisch xD

 

[Firephoenix]

du kannst das ja so angehen:
pseudocode

public int rev(int value){
if(Ankerbedingung){
return ...; //Rekursionsanker
}
letztestelle von value * 10^(anzahlstellen-1) + rev(rest von value);
}

 

[IloveJava]

Vielen Dank für eure super schnelle und ausführliche Hilfe