somme récursive de tous les chiffres d'un nombre

Avec les fonctions récursives, c'est généralement une bonne idée de commencer par le cas le plus basique, puis d'ajouter progressivement de la complexité.

De plus, une astuce utile est de prendre list () d'une chaîne coupe la chaîne en caractères, ergo list ("abc") renvoie ["a", "b", "c"] .

En utilisant ceci, nous obtenons:

def digital_root(n):
    # basic scenario: n is 1 digit, ergo <10. 
    if n < 10:
         return n

    # alternative case: more than 1 digit
    # cut n into digits with a list comprehension
    # str(714) => "714", list(str(714)) => "['7', '1', '4']
    digits = [int(c) for c in list(str(n))]

    # take the digital root of the sum
    return digital_root(sum(digits))

Vous ne faites rien avec le résultat de votre appel récursif - c'est pourquoi votre code tourne mal.

L'itération via index n'est généralement pas bonne - mieux vaut parcourir directement la chaîne.

Ceci est un moyen plus propre pour la récursivité en utilisant des fonctions python intégrées : p >

  1=>  1|  2=>  2|  3=>  3|  4=>  4|  5=>  5|  6=>  6|  7=>  7|
  8=>  8|  9=>  9| 10=>  1| 11=>  2| 12=>  3| 13=>  4| 14=>  5|
 15=>  6| 16=>  7| 17=>  8| 18=>  9| 19=>  1| 20=>  2| 21=>  3|
 22=>  4| 23=>  5| 24=>  6| 25=>  7| 26=>  8| 27=>  9| 28=>  1|
 29=>  2| 30=>  3| 31=>  4| 32=>  5| 33=>  6| 34=>  7| 35=>  8|
 36=>  9| 37=>  1| 38=>  2| 39=>  3| 40=>  4| 41=>  5| 42=>  6|
 43=>  7| 44=>  8| 45=>  9| 46=>  1| 47=>  2| 48=>  3| 49=>  4|
 50=>  5| 51=>  6| 52=>  7| 53=>  8| 54=>  9| 55=>  1| 56=>  2|
 57=>  3| 58=>  4| 59=>  5| 60=>  6| 61=>  7| 62=>  8| 63=>  9|
 64=>  1| 65=>  2| 66=>  3| 67=>  4| 68=>  5| 69=>  6| 70=>  7|

Sortie:

def rec_sum(n):
    sn = str(n)
    # base case - return the number
    if len(sn)==1:
        return n

    # not the base case,return whatever the recursive output returns
    return rec_sum(sum(map(int,sn)))


for n in range(1,71):
    print(f"{n:3}=>{rec_sum(n):3}", end = "|")
    if n%7 == 0:
        print()

La partie sum (map (int, sn)) signifie: map (function, iterable) applique la fonction int () à tous les caractères de sn (les chaînes sont itérables) qui est la chaîne de votre nombre . Ensuite, il sum () se déclenche et s'appelle avec cette somme.

Le principal problème est que, lorsque vous effectuez les appels récursifs, vous n'attribuez la valeur de retour à rien, vous obtiendrez donc toujours 0 pour toute valeur qui nécessite plus d'un passage.

De plus, après le appel récursif, la longueur doit être de 1 donc le elif suivant n'est pas nécessaire et entraînera des valeurs de retour incorrectes car il n'attribuera pas s à Answ code>

Version fixe:

def digital_root(n):
    answ = 0
    s = 0
    x = str(n)
    for i in range(0, len(x)):
        s = s + int(x[i])
    if len(str(s)) > 1:
       s = digital_root(s)
    answ = s # You could even return s directly
    return answ

print(digital_root(493193))

Voici mon point de vue. J'ai ressenti le besoin d'utiliser sum mais cela ressemble presque à de la triche puisque vous pouvez simplement utiliser sum ([int (i) for i in str (n)]) . < pré> XXX

Que dites-vous à ce sujet:

def digital_root(n):
    if n<10 :
         return n
    return digital_root( n%10 + digital_root( n//10 ) )