Programmieren lernen

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

// C++ 14 | VS-2022
#include <iostream>
class debt {
    double total_debt_{};                       // Gesamtschuld
    double rate_of_interest_{};                 // Zinsfuss
    double repayment_yearly_{};                 // Rückzahlungsbetrag jährlich
    double years_{};                            // Jahre
    double total_interest_{};                   // Gesamtzins
    double residual_debt_{ total_debt_ };       // Restschuld
    bool validate_input();
    void compute();

public:
    debt(double total_debt, double rate_of_interest, double repayment_yearly) :
        total_debt_{ total_debt }, rate_of_interest_{rate_of_interest}, repayment_yearly_{repayment_yearly}{
        if (!validate_input()) return;
        compute();
    }
    double get_total_years();
    double get_effective_interest_rate();
    double get_repayment_amount();
    double get_last_repayment();
    friend std::ostream& operator<<(std::ostream&, debt);
};

void debt::compute() {
    while (true) {
        ++years_;
        const auto tmp{ residual_debt_ * rate_of_interest_ / 100.0 };
        total_interest_ += tmp;
        const auto next{ residual_debt_ + tmp - repayment_yearly_ };
        if (next < 0) break;
        residual_debt_ = next;
    }
}

bool debt::validate_input() {
    return !(total_debt_* rate_of_interest_ / 100 > repayment_yearly_);
}

double debt::get_total_years() {                // Jahre für Rückzahlung
    return years_;
};

double debt::get_effective_interest_rate() {    // Effektivzins
    return total_interest_ / total_debt_ * 100;
}

double debt::get_repayment_amount() {           // Rückzahlungsbetrag gesamt
    return total_debt_ + total_interest_;
}

double debt::get_last_repayment() {             // letzter Rückzahlungsbetrag
    return total_interest_;
}

std::ostream& operator<<(std::ostream& os, debt d) {
    os << "Die Rueckzahlung dauert " << d.get_total_years() << " Jahre.\n";
    os << "Total wurden " << d.get_repayment_amount() << " Franken zurueckbezahlt.\n";
    os << "Dies entspricht einem Totalzins von " << d.get_effective_interest_rate() << "%.\n";
    os << "Die letzte Rueckzahlung betrug " << d.get_last_repayment() << " Franken.\n";
    return os;
}

int main() {
    const auto d{ debt{2000, 3, 500} };
    std::cout << d;
}
                

Lösung von: Jens Kelm (@JKooP)

// NET 7.x | C# 11.x | VS-2022
var debt = new Debt(2000, 3, 500);
Console.WriteLine(debt);

class Debt {
    public Debt(double totalDebt, double rateOfInterest, double repaymentYearly) {
        if (!ValidInput) return;
        TotalDebt = totalDebt;
        RateOfInterest = rateOfInterest;
        RepaymentYearly = repaymentYearly;
        ResidualDebt = TotalDebt;
        Compute();
    }
    private void Compute() {
        while (ResidualDebt > 0) {
            TotalYears++;
            var tmp = ResidualDebt * RateOfInterest / 100.0;
            TotalInterest += tmp;
            ResidualDebt += tmp - RepaymentYearly;
        }
    }

    private double TotalDebt { get; } // Gesamtschuld
    private double RateOfInterest { get; } // Zinsfuss
    private double RepaymentYearly { get; } // Rückzahlungsbetrag jährlich
    private double TotalInterest { get; set; } // Gesamtzins
    private double ResidualDebt { get; set; } // Restschuld
    private bool ValidInput => !(TotalDebt * RateOfInterest / 100 > RepaymentYearly); // Eingaben prüfen
    public double TotalYears { get; private set; } // Jahre
    public double EffectiveInterestRate => Math.Round(TotalInterest / TotalDebt * 100, 2); // Effektivzins
    public double RepaymentAmount => Math.Round(TotalDebt + TotalInterest, 2); // Rückzahlungsbetrag gesamt
    public double LastRepayment => Math.Round(TotalInterest, 2); // letzter Rückzahlungsbetrag
    public override string ToString() =>
        $"Die Rueckzahlung dauert {TotalYears} Jahre.\n" +
        $"Total wurden {RepaymentAmount} Franken zurueckbezahlt.\n" +
        $"Dies entspricht einem Totalzins von {EffectiveInterestRate}%.\n" +
        $"Die letzte Rueckzahlung betrug {LastRepayment} Franken.\n";
}
                

Lösung von: Jens Kelm (@JKooP)