Quersumme der Zahl n rekursiv berechnen

Question

Aufgabe:

Es geht darum, eine Funktion zu erstellen, die rekursiv (nicht iterativ) die Quersumme der Zahl n berechnet.

Diese Funktion wird dann später mit einer Zahl in der main Funktion aufgerufen und mit Zahlen ausprobiert.

Der Code compiliert auch ohne Fehler jedoch dürfte bei der Berechnung etwas nicht stimmen, da z. B. beim Beispiel 123 etwas um die 4567906 herauskommt und eigentlich ja 6 herauskommen sollte.

Mein Code:

unsigned digit_sum(int n) {
   if(n != 0)
       return n % 10 + digit_sum(n / 10);
   else
       return 0;
}

Comments

da z.B beim Beispiel 123 was um die 4567906 rauskommt

Kann ich nicht nachvollziehen. Bei mir liefert dein Code das korrekte Ergebnis. Zeig mal, wie du das Ergebnis überprüft hast.

Falsche Ergebnisse liefert deine Funktion bei negativem n.

Answer 1

Antwort mit KI erzeugt

Quersumme der Zahl n rekursiv berechnen

Um die Quersumme (oder Digitalsumme) einer Zahl \( n \) rekursiv zu berechnen, müssen wir die einzelnen Ziffern der Zahl addieren. Eine rekursive Funktion ist besonders gut für diese Aufgabe geeignet, da wir jede Ziffer der Zahl isolieren und dem Ergebnis der Quersumme der restlichen Ziffern hinzufügen können.

Analyse des rekursiven Ansatzes:

1. Basisfall: Wenn \( n = 0 \), geben wir 0 zurück. Das bedeutet, dass wir keine weiteren Ziffern mehr zu addieren haben.
2. Rekursiver Teil: Hier zerlegen wir die Zahl in ihre letzte Ziffer \( n \% 10 \) und die restliche Zahl \( n / 10 \). Die letzte Ziffer wird zur Quersumme der restlichen Ziffern hinzugefügt.

Damit ergibt sich für die Funktion digit_sum der einfache Ablauf:
- Die letzte Ziffer der Zahl (\( n \% 10 \)) wird zur rekursiven Summe der übrigen Ziffern (\( digit_sum(n // 10) \)) addiert.

Der von dir gegebene Code ist grundsätzlich korrekt. Der Fehler, den du erlebst, könnte auf einen Druckfehler oder einen Zahlentypfehler (z.B. unsigned/int) in anderen Teilen deines Codes zurückzuführen sein.

Sicherstellen, dass der Code korrekt ist:

Hier ist der Code für eine rekursive Funktion zur Berechnung der Quersumme:

cpp
#include <iostream>

// Funktion zur Berechnung der Quersumme einer Zahl n
unsigned digit_sum(int n) {
    // Basisfall: Wenn n 0 ist, geben wir 0 zurück
    if (n == 0)
        return 0;
    // Rekursiver Fall: Berechne Quersumme der restlichen Zahl und addiere letzte Ziffer
    else
        return n % 10 + digit_sum(n / 10);
}

int main() {
    int number;
    std::cout << "Geben Sie eine Zahl ein: ";
    std::cin >> number;
    std::cout << "Die Quersumme von " << number << " ist " << digit_sum(number) << std::endl;
    return 0;
}

Rechenbeispiel:

Für die Zahl 123:

1. \( n = 123 \)
- letzte Ziffer = 3 (\(123 \% 10\))
- restliche Zahl = 12 (\(123 / 10\))
- \( digit\_sum(123) = 3 + digit\_sum(12) \)

2. \( n = 12 \)
- letzte Ziffer = 2 (\(12 \% 10\))
- restliche Zahl = 1 (\(12 / 10\))
- \( digit\_sum(12) = 2 + digit\_sum(1) \)

3. \( n = 1 \)
- letzte Ziffer = 1 (\(1 \% 10\))
- restliche Zahl = 0 (\(1 / 10\))
- \( digit\_sum(1) = 1 + digit\_sum(0) \)

4. \( n = 0 \)
- Basisfall: Rückgabe = 0

Zusammengefasst ergibt dies:
\( digit\_sum(123) = 3 + 2 + 1 = 6 \)

Wenn du das Programm mit der Zahl 123 ausführst, sollte es korrekt die Quersumme 6 zurückgeben.

Ausgabe:

plaintext
Geben Sie eine Zahl ein: 123
Die Quersumme von 123 ist 6