Hilfe bei Rekursion

**Die Aufgaben Stellung: **

Ein Geldbetrag, der mit einem (jahrlichen) konstantem Zinssatz verzinst wird, wachst
exponentiell und kann nach der folgenden Berechnungsvorschrift:
Bi = Bi fur i=0;
Bi= (1+Z)*Bi1 sonst,
ermittelt werden, wobei Bi das Endguthaben nach dem i-ten Anlagejahr der Laufzeit
und Z der Zinsfaktor ist (d.h. fur 5% Zinsen ist Z = 0.05).
Schreiben Sie ein Programm, das folgende Informationen einliest: der Geldbetrag, den
Zinssatz und die Laufzeit.
Das Programm soll eine Methode calculateAmount(Geldbetrag, Zinssatz,
Laufzeit) implementieren, die die oben beschriebene Berechnungsvorschrift in eine
Rekursion umsetzt, um das Guthaben zum Ende der Laufzeit zu berechnen. Die
Methode gibt das berechnete Guthaben (auf zwei Nachkommastellen gerundet) zuruck.
Das Programm ruft diese Methode in der main-Methode auf, um die Investition fur
eingelesene Informationen zu berechnen und gibt das berechnete Guthaben aus.

Kann mir einer Helfen und mir zeigen wie ich diese Rekursion programmiere?

Mein Quelltext bisher, ich weiß hässlich programmiert :wink: :

package grundlagenuebungen;

import java.util.Scanner; // Ist für Benutzderdefinierte eingaben im output zurständig

public class InterestRate
{

    public static void main(String[] args)
    {

        float result = 0; // Wird unten definiert

        Scanner sc = new Scanner(System.in); // Das im Output die Eingabe
                                             // erkannt wird

        int x = 0;// Ist Wichtig für den IF bedingungs durchlauf
        int y = 0;// Ist Wichtig für den else IF bedingungs durchlauf
        // Ist der Fixe Zinssatz

        System.out.println("Geben Sie den Einzahlungsbetrag ein:");
        float basicValue = sc.nextFloat(); // Ist der Variable Einzahlungsbetrag
                                           // über oder unter 1000 €

        System.out
            .println("Geben Sie die gewünschte Anlegezeit in Jahren ein:");
        float runtime = sc.nextFloat(); // Ist die Variable Anlegedauer von 1
                                        // bis n Jahre

        System.out.println("Zinssatz Bitte bestimmen: ");
        float interest = sc.nextFloat();
        for (int i = 1; i <= runtime; i++) // Ist die Hauptschleife die den
                                           // monatliche ertrag aus den Zinsen
                                           // berechnet
        {

            if (basicValue > 1000 && x == 0) // Ist die bedingung für einen
                                             // Einlagebetrag größer als 1000
                                             // €
            /*
             * läuft nur wenn mehr als 1000 € eingezahlt werden und läuft
             * auch nur einmal durch
             */
            {
                interest++; // hier wird der Zinsatz um 1 erhöht
                x++; // hier ist definiert das die Bedingung nur einmal erfüllt
                     // wird
            }
            else if (i >= 4 && y == 0) // Ist die bedingung für einen
                                       // Anlegezeit in Jahren
            /* und wird erst erfüllt wenn mehr als 3 Jahre Geld angelegt wird */
            {
                interest++;// hier wird der Zinssatz um 1 erhöht
                y++;// hier ist definiert das die Bedingung nur einmal erfüllt
                    // wird
            }
            result = basicValue * ((interest / 100) + 1); // Berechnung des
                                                          // Ertrages aus den
                                                          // Zinsen mal dem
                                                          // Einlagebetrag
            basicValue = result; // Definiton des Ertrages

            // System.out.println(Math.round(result*100.)/100.); Ausgabe nach
            // jeder Berechnung
        }
        System.out.println(Math.round(result * 100.) / 100.);

    }
}

Eigentlich steht die Rekursion schon fast in der Definition, und ich ich kann mir keinen geeigneten “Zwischenschritt” vorstellen, der zwischen der Definition und der Lösung liegt. Aber ein Versuch: Es sollte wohl eine Methode geben wie

private static double berechne(double betrag, int jahre) { ... }

die sich selbst aufruft.

Schick schick, aber bewertete aufgaben solltest du besser alleine und nicht oeffentlich loesen. Sonst faellst du durch.
Gruesse von deiner uni

[QUOTE=Clz-plagiaterie]Schick schick, aber bewertete aufgaben solltest du besser alleine und nicht oeffentlich loesen. Sonst faellst du durch.
Gruesse von deiner uni[/QUOTE]

LOL, dumm gelaufen. Wenn es nicht nur ein Scherz ist :smiley: