Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Schuldtilgung (Schleifen)

Schreiben Sie ein Programm, bei dem ausgegeben wird, nach wie vielen Jahren eine anfängliche Schuld getilgt sein wird. Zusätzlich soll ausgegeben werden, wie viel insgesamt bezahlt wurde, um die Schuld zu tilgen, und welches die letzte Rückzahlung ist.

Als Eingabe erhält Ihr Programm die anfänglich geschuldete Summe, den Jahres-Zinsfuß und den jährlichen Rückerstattungsbetrag.

Gehen Sie davon aus, dass die Rückzahlungen jährlich erfolgen und dass die erste Rückzahlung erst nach einem Jahr - also nach der ersten Verzinsung - geschieht (nachschüssig).

Bemerkung: Falls der Jahreszins höher ist als der Rückerstattungsbetrag, kann die Schuld logischerweise nicht zurückerstattet werden. Geben Sie dies als Meldung aus.

 

(Weiterführende Literatur zur Schuldnerberatung hier: www.kreditzentrale.com/files/ebooks/schuldnerberatung.pdf)

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

12 Lösung(en)

import java.util.Scanner;

/**
 * Schuldtilgung.
 * Eingabe: Totalschuld, Jahreszins, Jährliche Rückzahlung
 * Ausgabe: Anzahl jahre, total geleisteter Betrag, Betrag im letzten Jahr
 * @author Philipp Gressly (phi@gressly.ch)
 */
/*
 * History: first Implementation: 20.01.2011
 * Bugs: Rundungsfehler in "real"-Zahlen werden vernachläßigt.
 */
public class Schuldtilgung {
  public static void main(String[] args) {
    new Schuldtilgung().top();
  }
  
  Scanner sc = new Scanner(System.in);
  double einlesenZahl(String frage) {
      System.out.println("Bitte geben Sie " + frage + " ein: ");
      return sc.nextDouble();
  }
  
  
  double gesamtschuld;
  double zinsfuss;
  double jaehrlicheRueckzahlung;
  
  int    jahre;
  double restschuld;
  double aktuellerZins;
  double totalGeleistet;
  double letzteRueckzahlung;
  
  void top() {
      gesamtschuld           = einlesenZahl("die Gesamtschuld");
      zinsfuss               = einlesenZahl("den Jahreszinsfuss");
      jaehrlicheRueckzahlung = einlesenZahl("die jaehrliche Rueckzahlung");
      
      // starte Simulation
      jahre = 0;
      restschuld = gesamtschuld;
      totalGeleistet = 0;
      while(restschuld > 0) {
          jahre = jahre + 1;
          aktuellerZins = restschuld * zinsfuss / 100;
          if(aktuellerZins > jaehrlicheRueckzahlung) {
              System.out.println("Die Schuld kann bei diesem Zins (" + aktuellerZins + ") nie zurückbezahlt werden.");
              System.exit(0); // oder "return", je nach Programmiersprache
          }
          restschuld = restschuld + aktuellerZins;
          if(restschuld < jaehrlicheRueckzahlung) {
              totalGeleistet = totalGeleistet + restschuld;
              letzteRueckzahlung = restschuld;
              restschuld = 0;
          } else {
              restschuld = restschuld - jaehrlicheRueckzahlung;
              totalGeleistet = totalGeleistet + jaehrlicheRueckzahlung;
              letzteRueckzahlung = jaehrlicheRueckzahlung;
          }
      } // end while
      System.out.println("Die Rückzahlung dauert " + jahre + " Jahre.");
      System.out.println("Total wurden " + totalGeleistet + " Franken zurückbezahlt.");
      System.out.println("Dies entspricht einem Totalzins von " + (100.0 * totalGeleistet / gesamtschuld - 100)+ "%.");
      System.out.println("Die letzte Rückzahlung betrug " + letzteRueckzahlung + ".");
  }
  
} // end of class Schuldtilgung
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

#!/usr/bin/ruby

# @autor Philipp Gressly Freimann
# 2011 Feb
# Berechne die Schuldtilgung

def einlesen(wert) 
  print "Bitte #{wert} eingeben:"
  # Dezimalzahl (real) einlesen:
  return STDIN.gets.to_f
end


gesamtschuld           = einlesen("zu tilgende Schuld")
zinsfuss               = einlesen("Zinsfuss")
jaehrlicheRueckzahlung = einlesen("Jährliche Rückzahlung")

# starte simulation:
jahre = 0
restschuld = gesamtschuld
totalGeleistet = 0
while(restschuld > 0)
  jahre = jahre + 1
  aktuellerZins = restschuld * zinsfuss / 100
  if(aktuellerZins > jaehrlicheRueckzahlung) 
    puts "Die Schuld kann bei diesem Zins (#{aktuellerZins}) nie zurückbezahlt werden."
    exit
  end
  restschuld = restschuld + aktuellerZins
  if(restschuld < jaehrlicheRueckzahlung)
    totalGeleistet     = totalGeleistet + restschuld
    letzteRueckzahlung = restschuld
    restschuld         = 0
  else
    restschuld         = restschuld - jaehrlicheRueckzahlung
    totalGeleistet     = totalGeleistet + jaehrlicheRueckzahlung
    letzteRueckzahlung = jaehrlicheRueckzahlung
  end
end

puts "Die Rückzahlung dauert #{jahre}"
puts "Total wurden #{totalGeleistet} Franken zurückbezahlt."
puts "Dies entspricht einem Totalzins von #{100 * totalGeleistet / gesamtschuld - 100}."
puts "Die letzte Rückzahlung betrug #{letzteRueckzahlung}."
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

/**
 * Autor: ph. gressly 
 * Datum: 21. April 2011 
 * Berechne diverse Größen bei naschschüssiger Schuldtilgung.
 * www.programmieraufgaben.ch
 */

#include <stdio.h>


void einlesen(char* prompt, float* wert) {
  printf("%s: ", prompt);
  scanf ("%f",   wert)  ;
}

/**
 * Einlesen der Größen.
 */
void eingabe(float* schuld, float* zins, float* rueckzahlung) {
  einlesen("Anfangsschuld"        , schuld)      ;
  einlesen("Zinsfuss     "        , zins)        ;
  einlesen("Jährliche Rückzahlung", rueckzahlung);
}


void simulation(float  anfangsschuld, float zinsfuss, float jahresrueckzahlung,
             float* anzahlJahre,   float* letzteRueckzahlung, float* totalZurueckbezahlt) {
  float restschuld     = anfangsschuld;
  *totalZurueckbezahlt =             0;
  *anzahlJahre         =             0;
  while(restschuld > 0) {
    restschuld   = restschuld * (1.0 + zinsfuss / 100.0);
    *anzahlJahre = *anzahlJahre + 1; 
    if(restschuld > jahresrueckzahlung) {
      restschuld           = restschuld - jahresrueckzahlung;
      *totalZurueckbezahlt = *totalZurueckbezahlt + jahresrueckzahlung;
    } else {
      *letzteRueckzahlung  = restschuld;
      *totalZurueckbezahlt = *totalZurueckbezahlt + restschuld;
      restschuld           = 0;
    }
  }  
}

void ausgabe(float anzahlJahre,   float letzteRueckzahlung, float totalZurueckbezahlt) {
  printf("Anzahl Jahre       : %d\n", (int) anzahlJahre  );
  printf("Letzte Rückzahlung : %f\n", letzteRueckzahlung );
  printf("Total Zurückbezahlt: %f\n", totalZurueckbezahlt);  
}

/**
 * Hauptprogramm:
 * Eingabe: Anfängliche Schuld, Zinsfuss und mögliche jährliche naschschüssige Rückzahlung.
 * Ausgabe: a) Anzhl Jahre, b) Letzte Lückzahlung, c) Total zurückbezahlter Betrag.
 */
main() {
  float anfangsschuld, zinsfuss, jahresrueckzahlung;
  eingabe(&anfangsschuld, &zinsfuss, &jahresrueckzahlung);

  float anzahlJahre, letzteRueckzahlung, totalZurueckbezahlt;

  simulation(anfangsschuld, zinsfuss, jahresrueckzahlung, &anzahlJahre, &letzteRueckzahlung, &totalZurueckbezahlt);

  ausgabe(anzahlJahre, letzteRueckzahlung, totalZurueckbezahlt);

}
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

<?xml version="1.0" encoding="utf-8" ?>

<html xmlns="http://www.w3.org/1999/xhtml">
 <head>
  <title>Hallo du...</title>
  <meta http-equiv = "Content-Script-Type" content = "text/javascript" />
  <script type="text/javascript" src="code.js"></script>
 </head>
 <body>
  <form>
	 <h1>Schuldentilgung</h1>
	 Schulden in CHF: <input type="text" id="schulden" /><br/>
	 Jahres-Zinsfuss: <input type="text" id="zins"  /><br/>
	 Rückerstattungsbetrag (jährlich) :<input type="text" id="rueck" /><br/>
	 <br/>
	
	 <input type="button" value="Rechnen" onclick="nichtmoeglich();"/>
	 <input type="reset" value="Reset" />
	 <p id="ausgabe1"></p>
 </form>	
 </body>
</html> 

------------------------------------------------------------------------------------

function hauptprogramm(schulden, zins, rueck) {
	var ausgabe  = document.getElementById("ausgabe");
	var ausgabe1 = document.getElementById("ausgabe1");
	ausgabe1.innerHTML = "Jahre = " + res(schulden, zins, rueck);
}

function res(schulden, zins, rueck) {
	var counter = 0;
	var totalschulden = 0;
	while (schulden >= 0) {
		counter = counter + 1;
		totalschulden = totalschulden + rueck;
		schulden = schulden+(schulden/100)*zins;
		schulden = schulden - rueck;
		if (schulden < 0) {
			totalschulden = totalschulden + schulden;
		}
		var	zuletzbezahlt = rueck + schulden;
	}	
	return counter + " / Totale Schulden " + totalschulden + " / Zuletzt bezahlte " + zuletzbezahlt;
}

function nichtmoeglich() {
	var schulden = document.getElementById("schulden").value*1;
	var zins     = document.getElementById("zins").value*1;
	var rueck     = document.getElementById("rueck").value*1;
	
	var resultat = (schulden/100)*zins;
	
	if (resultat >= rueck) {
		window.alert("Mit diesem Zinsfuss / Rückerstattung ist die Rückzahlung nicht möglich");
	} else {
		hauptprogramm(schulden, zins, rueck);
	}
}
                

Lösung von: Raphael Hirsiger (Credit Suisse)

<?xml version="1.0" encoding="utf-8" ?>

<html xmlns="http://www.w3.org/1999/xhtml">
 <head>
  <title>Schuldentilgung</title>
  <meta http-equiv = "Content-Script-Type" content = "text/javascript" />
  <script type="text/javascript" src="code.js"></script>
 </head>
 <body>
 <form>
	<h1>Schuldtilgung</h1>
	<p>zu schuldende Summe  :<input type="text" id="s1" /><br/>
	Jahres-Zinsfuss         :<input type="text" id="s2" /><br/>
	Rückerstattungsbetrag   :<input type="text" id="s3" /><br/></p>
	<br/>
	
	<input type="button" value="Rechnen" onclick="hauptprogramm();"/>
	<input type="reset" value="Reset" /><br />
	Getilgt in: <p id="ausgabe"></p> 
	letzte Rückzahlung: <p id="ausgabe2"></p>
</form>	
 </body>
</html> 
<!-------------------------------------------------------------------------------!>
///////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////
// Programm: Schuldentilgung       //
/////////////////////////////////////

function hauptprogramm() {
   var schuldensum            = document.getElementById("s1").value * 1;
   var zinsfuss               = document.getElementById("s2").value * 1;
   var rueckerstattung        = document.getElementById("s3").value * 1;
   var resultate              = rechnen(schuldensum, zinsfuss, rueckerstattung); 
   ele = document.getElementById("ausgabe");
   ele.innerHTML = resultate["jahre"];  
   ele2 = document.getElementById("ausgabe2");
   ele2.innerHTML = resultate["letztezahlung"];  
}

function rechnen(schuldensum, zinsfuss, rueckerstattung) {
   result        = new Array();
   jahre         = 0;
   total         = 0;
   letztezahlung = 0;
   
   while (schuldensum > 0){
      total = total + rueckerstattung;
	  jahre = jahre + 1;
      schuldensum = (schuldensum / 100) * (100 + zinsfuss);
	  schuldensum = schuldensum - rueckerstattung;
	  
	  
	  if (schuldensum < 0) {
         letztezahlung =  rueckerstattung + schuldensum;   
      }
   } 
 
   result["jahre"]         = jahre;
   result["total"]         = total;
   result["letztezahlung"] = letztezahlung;
   
   return result;   
}
                

Lösung von: Arik Guggenheim (Credit Suisse)

HTML Code:
<?xml version="1.0" encoding="utf-8" ?>

<html xmls = "http://www.w3.org/1999/xhtml">
  <head>
    <title> Javascript Extern </title>
	<meta http-equiv = "Content-Script-Type"
	         content = "text/javascript" />
	<script   type = "text/javascript"
	           src = "aufg10.js"></script>
  </head>
  <body >
	<h1> Schuldtilgung </h1>
	Schulden
	<input type="text" id="EingabeA" />
	Zinsfuss
	<input type="text" id="EingabeB" />
	Rückerstattung
	<input type="text" id="EingabeC" />
	<input type="button" value="Berechnen" onclick="Ausfuehrung();" />
	<p id="jahrID"> </p>
	<p id="gesamtID"> </p>
	<p id="letzteID"> </p>
  </body>
</html>  
**********************************************************************
JS code:
// Author : R.Scholz
// Datum  : 15.04.2011

function Ausfuehrung(){
	eingabeSchulden            = document.getElementById("EingabeA").value * 1;
	eingabeZinsfuss            = document.getElementById("EingabeB").value * 1;
	eingabeRueckerstattung     = document.getElementById("EingabeC").value * 1;

	
	paragraphElement           = document.getElementById("jahrID");
	paragraphElement.innerHTML = "Die Schulden sind nach:" + berechnung(eingabeSchulden, eingabeZinsfuss, eingabeRueckerstattung) + "Jahren beglichen";
	
	paragraphElement           = document.getElementById("gesamtID");
	paragraphElement.innerHTML = "Der gesamte Betrag war:" + berechnungGesamt(eingabeSchulden, eingabeZinsfuss, eingabeRueckerstattung);
	
	paragraphElement           = document.getElementById("letzteID");
	paragraphElement.innerHTML = "Die letzte Rückerstattung betrug:" + berechnungLetzteRueckzahlung(eingabeSchulden, eingabeZinsfuss, eingabeRueckerstattung);
}
// s= Schulden
// z= Zinsfuss
// r= Rückerstattung
function berechnung(s, z, r){
	var zaehler = 0;
	
	while(s > 0){
		
		s       = s + ( s / 100 * z);
		s       = s - r;
		zaehler = zaehler + 1;

	}
	return zaehler;
}

function berechnungGesamt(s, z, r){
	var zaehler = 0;
	var gesamt  = 0;
	while(s > 0){
		
		s       = s + ( s / 100 * z);
		s       = s - r;
		zaehler = zaehler + 1;
		
	}
	gesamt   = r * (zaehler - 1);
	s        = s + r;
	gesamt   = gesamt + s;
	return gesamt;
}

function berechnungLetzteRueckzahlung(s, z, r){
	var zaehler = 0;
	var gesamt  = 0;
	while(s > 0){
		
		s       = s + ( s / 100 * z);
		s       = s - r;
		zaehler = zaehler + 1;
		
	}
	gesamt   = r * (zaehler - 1);
	s        = s + r;
	return s;
}
                

Lösung von: Ramon Scholz (Credit Suisse)

def schuldtilgung(geschuldeteSumme, jahresZinsfuss, betragProJahr):
    ''' author: rethab.ch '''

    jahreZurRueckzahlung = 0
    insgesamtBezahlt = 0
    letzterBetrag = 0 #laufend aktualisieren, letzter zaehlt
    while geschuldeteSumme > 0:
        belasteterZins = float(geschuldeteSumme) / 100 * jahresZinsfuss
        geschuldeteSumme += belasteterZins #zins belasten
        
        # koennen wir das bezahlen?
        if betragProJahr <= geschuldeteSumme / 100 * jahresZinsfuss:
            print 'Nicht bezahlbar!'
            return
        
        #wie viel muessen wir effektiv bezahlen?
        if betragProJahr > geschuldeteSumme:
            letzterBetrag = geschuldeteSumme
        else: 
            letzterBetrag = betragProJahr
        insgesamtBezahlt += letzterBetrag
        geschuldeteSumme -= letzterBetrag
        jahreZurRueckzahlung = jahreZurRueckzahlung + 1
    print 'Waehrend %d Jahren wurden insgesamt %0.2f bezahlt. ' \
          'Die letzte Rate betrug %0.2f.' % \
            (jahreZurRueckzahlung, insgesamtBezahlt, letzterBetrag)
                

Lösung von: Reto Hablützel (www.rethab.ch)

// Autor:				Andy Großhennig
// Solution for task:	Schuldtilgung (Schleifen)

#include <iostream>

using namespace std;

// Structure: Debt prototype
struct Debt
{
	double iDebt, iRefund, iInterest;
};

// Function: Get the debt data
void getData(Debt *debt)
{
	printf("Wie hoch ist die Gesamtschuld? ");
	cin >> debt->iDebt;
	printf("\nWieviel wird jaehrlich zurueckgezahlt? ");
	cin >> debt->iRefund;
	printf("\nWie hoch sind die jaehrlichen Zinsen? ");
	cin >> debt->iInterest;
}

// Function: Calculate the decrease
void calculate(Debt *debt, double *iTotalMoney)
{
	// If: Check whether the decrease set the debt lower than zero
	if(debt->iDebt - debt->iRefund >= 0)
	{
		*iTotalMoney += debt->iRefund;
		debt->iDebt -= debt->iRefund;
	}
	else
	{
		printf("\nDie letzte Rueckzahlung betrug: %.2f\n", debt->iDebt);
		*iTotalMoney += debt->iDebt;
		debt->iDebt -= debt->iDebt;
	}
}

// Function: Manage the decrease
void liabilities()
{
	Debt debt;
	int iYears = 0;
	double iTotalMoney = 0;

	getData(&debt);

	while(debt.iDebt > 0)
	{
		debt.iDebt +=  (debt.iDebt / 100) * debt.iInterest;
		iYears++;

		// If: Check whether the refund is higher than the interest
		if((debt.iDebt / 100) * debt.iInterest > debt.iRefund)
		{
			printf("\nDie Zinsen sind hoeher als die Rueckerstattung!");
			return;
		}

		calculate(&debt, &iTotalMoney); 
	}

	printf("Nach %i Jahren wurden %.2f Mark zurueck gezahlt", iYears, iTotalMoney);
}

int main()
{
	liabilities();
	
	printf("\n\n");
	system("Pause");
	return 0;
}
                

Lösung von: Andy Großhennig (Bundeswehr)

'''
Python 3.4.2
'''

def schuldtilgung():
    schuldbetrag = float(input('Wieviel betraegt der Schuldbetrag? '))
    zinsfuss = float(input('Was ist der Jahreszins? '))
    annuitaet = float(input('Was ist der jaehrliche Rueckzahlungsbetrag? '))

    if (schuldbetrag * zinsfuss / 100) > annuitaet:
        print('\nJahreszins ist höher als der Rückerstattungsbetrag!\n'
              'Bitte andere Werte eingeben.\n')
        schuldtilgung()  # Funktion neu aufrufen

    jahre = gesamtzins = effektivzins = 0
    restschuld = schuldbetrag

    while restschuld > 0:
        gesamtzins += (restschuld * zinsfuss / 100)
        restschuld = restschuld + (restschuld * zinsfuss / 100) - annuitaet
        jahre += 1

    effektivzins = gesamtzins / schuldbetrag * 100

    print('\nDie Rückzahlung dauert', jahre, 'Jahre.')
    print('Total werden', round(schuldbetrag + gesamtzins, 2), 'Franken zurückbezahlt.')
    print('Dies entspricht einem Totalzins von', round(effektivzins, 2),'%.')
    print('Die letzte Rückzahlung betraegt', round(annuitaet + restschuld, 2), '.')


if __name__ == '__main__':
    schuldtilgung()
                

Lösung von: Hilli Hilli ()

using System;

namespace Schuldtilgung {
	class Program {
		static void Main() {
			double
				kredit,
				startBetrag,
				rate,
				zins;
			int
				jahre = 0;

			try {
				Console.Clear();

				Console.Write("Kredithöhe> ");
				kredit = Convert.ToDouble(Console.ReadLine());
				startBetrag = kredit;

				Console.Write("Rate> ");
				rate = Convert.ToDouble(Console.ReadLine());

				Console.Write("Zinssatz> ");
				zins = Convert.ToDouble(Console.ReadLine());
			}
			catch (Exception) { return; }

			Console.WriteLine();

			if (rate <= kredit / 100 * zins) {
				Console.WriteLine("Der Kredit kann nicht zurückgezahlt werden.");
				Console.ReadKey(true);
				return;
			}

			for (; kredit > 0.0; jahre++) {
				kredit += kredit / 100 * zins;
				kredit -= rate;
			}

			Console.WriteLine("Die Rückzahlung dauert {0} {1}", jahre, jahre > 1 ? "Jahre" : "Jahr");
			Console.WriteLine("Total wurden {0:C} zurückgezahlt.", rate * jahre + kredit);
			Console.WriteLine("Dies entspricht einem Totalzint von {0:P}", (rate * jahre + kredit) / startBetrag - 1);
			Console.WriteLine("Die letzte Rate beträgt {0:C}", rate += kredit);

			Console.ReadKey(true);
		}
	}
}
                

Lösung von: Marcel Kapma ()

// eingabemaske
document.write(
  '<input type="number" value="2000" id="debt" onchange="compute()"> ' +
    'Gesamtschuld (Taler)<br>' +
  '<input type="number" value="3" id="interest" onchange="compute()"> ' +
    'Jahreszinsfuß (%)<br>' +
  '<input type="number" value="500" id="payback" onchange="compute()"> ' +
    'Jährliche (nachschüssige) Rückzahlung (Taler)' +
  '<div id="out" style="margin-top:2em"></div>'
);

function compute() {
  var debt = parseInt(document.getElementById("debt").value),
      interest = parseInt(document.getElementById("interest").value),
      payback = parseInt(document.getElementById("payback").value),
      out = document.getElementById("out"),
      years = 0, yearTxt;
      total = 0,
      initialDebt = debt,
      lastPayback = 0;

  // fallabfrage: schuld > zinsfuß
  if (debt * interest / 100 > payback)
    out.innerHTML = '<iframe src="http://playit.pk/embed/uQQm7bKJskM"></iframe>';
  else {
    while (debt > 0) {
      years++;
      total += payback;
      debt += debt / 100 * interest;
      debt -= payback;
      if (debt < 0) total += debt;
      lastPayback = payback + debt;
    }
    // ausgabe
    yearTxt = years == 1 ? " Jahre.<br>" : " Jahre.<br>";
    out.innerHTML = (
      "Die Rückzahlung dauert " + years + yearTxt +
      "Total werden " + total.toFixed(2) + " Taler zurückbezahlt.<br>" +
      "Dies entspricht einem Totalzins von " +
        (total * 100 / initialDebt - 100).toFixed(2) +" %.<br>" +
      "Die letzte Rückzahlung beträgt " + lastPayback.toFixed(2) + " Taler."
    );
  }
}

                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

"Hinweis: Dieses Programm verwendet eine andere Variante der Zinsberechnung und kommt daher auf ein anderes Ergebnis.

REPORT /SVM/ZZR_TEST12ARON.

PARAMETERS: lv_schul    TYPE i,
            lv_zins     TYPE p DECIMALS 2,
            lv_rueck    TYPE i.

DATA: lv_zins2(6)       TYPE p DECIMALS 4,
      lv_schul2         TYPE p DECIMALS 2,
      lv_ges            TYPE p DECIMALS 2,
      lv_getilgt        TYPE char1,
      lv_jahr1          TYPE char1,
      lv_jahre          TYPE i.

lv_schul2  = lv_schul.
lv_ges     = 0.                             
lv_jahre   = 0.                                 
lv_getilgt = 'n'.                            
lv_jahr1   = 'j'.                              

lv_zins2 = lv_zins / 100.                     
lv_zins2 = lv_zins2 + 1.

IF ( lv_zins2 >= lv_rueck ).
    WRITE:/ 'Die Schuld kann mit dieser Rate nicht zurückgezahlt werden.'.
ELSE.

    WHILE lv_getilgt = 'n'.                     

        lv_schul2 = lv_schul2 * lv_zins2.    
        lv_jahre  = lv_jahre + 1.              

         IF lv_jahr1 = 'j'.               
            lv_jahr1 = 'n'.

         ELSE.
            IF lv_rueck  <= lv_schul2.           
               lv_schul2 = lv_schul2 - lv_rueck. 
               lv_ges    = lv_ges + lv_rueck.    
            ELSE.
               lv_ges    = lv_ges + lv_schul2.  
               lv_schul2 = 0.                    
            ENDIF.


        ENDIF.

        IF lv_schul2 <= 0.                      
           lv_getilgt = 'j'.                     
        ENDIF.

    ENDWHILE.

    WRITE:/ 'Die Schuld ist nach ', lv_jahre,' Jahren getilgt.'.
    WRITE:/ 'Der gesamte Rückzahlbetrag beträgt', lv_ges,'.'.

ENDIF.
                

Lösung von: Name nicht veröffentlicht

Verifikation/Checksumme:

Beispiel

Gesamtschuld: 2000
Jahreszinsfuss: 3 (%)
Jährliche (nachschüssige) Rückzahlung: 500

Die Rückzahlung dauert 5 Jahre.
Total wurden 2163.98 Franken zurückbezahlt.
Dies entspricht einem Totalzins von 8.20%.
Die letzte Rückzahlung betrug 163.98.

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 0.5
Schwierigkeit: Mittel
Webcode: 2f3t-o59h
Autor: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen