Python inverse entier en utilisant la récursivité

Je suis en train de travailler sur un problème qui a besoin d'inverse d'un nombre entier d'entrée sans l'aide de la liste ou de la ficelle.
Mais mon programme ne fait que retourner premiers et derniers chiffres.

def reverseDisplay(number):
   if number<10:
      return number 
   else:
      return reverseDisplay(number//10)
def main():
    number=int(input("Enter a number:"))
    print(number%10,end='')
    print(reverseDisplay(number))
main()

Il semble que la fonction d'inversion juste travaillé qu'une seule fois.

InformationsquelleAutor user1718826 | 2012-11-15

Cela devrait fonctionner:

from math import log10
def rev(num):
    if num < 10:
        return num
    else:
        ones = num % 10
        rest = num // 10
        #print ones, rest, int(log10(rest) + 1), ones * 10 ** int(log10(rest) + 1)
        return ones * 10 ** int(log10(rest) + 1) + rev(rest)
print rev(9000), rev(1234), rev(1234567890123456789)

Vous pouvez également réduire le nombre de fois que vous appelez log10 et le nombre d'opérations mathématiques à l'aide d'un imbriquée fonction récursive:

def rev(num):
    def rec(num, tens):
        if num < 10:
            return num        
        else:
            return num % 10 * tens + rec(num // 10, tens // 10)
    return rec(num, 10 ** int(log10(num)))

Vos points concernant ma solution a été totalement tache sur. Merci pour eux!

InformationsquelleAutor John Gaines Jr.

1

Il est exécuté plusieurs fois, mais il ne renvoie plus à gauche chiffre. Il est assez facile de voir que c'est le cas, si vous envisager dans quelles circonstances le if sera vrai.

Pour faire ce travail, vous devez l'ajouter dans les chiffres que vous avez ignoré que vous passez de la récursivité. Les ouvrages suivants, par simple virement de bord du passé de chiffres à gauche du résultat précédent. Je préfère le faire sans la conversion de chaîne de caractères, mais je ne pouvais pas venir avec une élégante façon de le faire...
```
def reverseDisplay(number):
   if number<10:
      return number 
   else:
      return int(str(number%10) + str(reverseDisplay(number//10)))
def main():
    number=int(input("Enter a number:"))
    print(number%10,end='')
    print(reverseDisplay(number))
main()
```
InformationsquelleAutor Allan
0
```
def reverseDisplay(number):
    if number<10:     
        return number                      #1 
    first_digit = number % 10              #2
    the_rest = reverseDisplay(number//10)
    ex = 0
    while 1:                               #3
        ex = ex + 1
        if number//(pow(10,ex)) == 0:
            break
    ex = ex - 1
    return first_digit*pow(10,ex) + the_rest #4
```
Voici comment cela fonctionne... (j'ai étiqueté les lignes Im se référant à ici)
- ligne 1: sortie de la condition. Mais vous savez ce
- ligne 2: obtenir le dernier chiffre. % moyen de trouver le reste de la division
- ligne 3: si par exemple on passe à 123. À ce stade, nous avons first_digit=3 et the_rest=21. Nous voulons que le résultat soit 321 = 300 + 21. Donc à peu près ce dont nous avons besoin est de savoir combien de fois nous avons besoin à la fois first_digit par 10 pour que cela fonctionne
- ligne 4: mmm délicieux
InformationsquelleAutor Sheena

Vous pouvez le faire par le maintien d'un supplément de compte qui garde une trace de la façon dont de nombreux chiffres ont été traitées avec déjà.

Cela peut être fait à l'aide d'une fonction wrapper:

def reverseRecursion(number, i):
    if number < 10:
        return number 
    else:
        return reverseRecursion(number//10, i+1) + (number % 10)*(10**i)

def reverseDisplay(number):
    return reverseRecursion(number, 1)

def main():
    number = 1234
    print(reverseDisplay(number))

main()

L'idée est d'utiliser le compteur de garder une trace de la façon dont beaucoup de zéros de fin pour ajouter le numéro actuel de faire le plus de travail.

Suivi par le biais de ce serait:

number = 1234

ans(123) + 40
ans(12) + 300 + 40
ans(1) + 2000 + 300 + 40
1 + 2000 + 300 + 40
=> 2341

InformationsquelleAutor Aamir

0

En vertu de l'hypothèse, que la récursivité n'était pas une obligation (toujours une bonne idée de le remplacer par itération si facilement possible), je suggère le code ci-dessous. J'ai changé le nom de la fonction pour des raisons de clarté et d'éviter la surenchère de puissance et logarithme des opérations dans d'autres suggestions.
```
def reverseNumber(n):
   assert isinstance(n, int) and n >= 0
   base = 10
   result = 0
   while n != 0:
      n, remainder = divmod(n, base)
      result = result*base + remainder
   return result
```
- mais il ne demande pas un générateur. Une réponse doit être RETOURNÉ
- Avec quelques modifications, ce serait une bien meilleure solution que la mienne. Il suffit de changer isinstance(n, int) pour isinstance(n, (int, long)) pour lui permettre de gérer de manière arbitraire des numéros longs, et d'appliquer pep8 (4 espace tirets). C'est apx 4x plus rapide que mon premier et 2x plus vite que mon deuxième solution.
InformationsquelleAutor guidot
0

Edit: C'est une solution de travail.
```
def rev(x, prod=0):
    if x < 10:
        return prod + x
    else:
        prod = prod * 10 + x%10 * 10
        return rev(x / 10, prod)
```
Résultat:
```
>>> rev(123)
321
>>> rev(12345)
54321
>>> rev(72823780029)
92008732827L
>>> rev(1)
1
```
- Posté le code ne fonctionne pas. Pour l'entrée, 123, dans 2.7.3 il retourne 51 et en 3.3.0 il retourne apx. 54.23. Peut-être que vous avez posté dans le mauvais code comme votre exemple de réponses d'utiliser un autre nom de la fonction?
- Gaines Jr Fixe.
InformationsquelleAutor Akavall

def inverte_digitos(n):
        def inverte_aux(n, n_novo):
                if n == 0:
                        return n_novo
                else:
                        return inverte_aux(n//10, n_novo*10+n%10)
        return inverte_aux(n, 0)

C'est ce que j'ai fait

InformationsquelleAutor Vasco

def reverseDisplay(number,k):
    if number >0:
        i=(k)*10+number%10
        j = number//10
        return reverseDisplay(j,i)
    else:
        return k

def main():
    number = 1234567
    print(reverseDisplay(number,0))

main()

InformationsquelleAutor Mahesh Kumar Ronde

Cela devrait fonctionner : vérifié sur Python3

# reverse a number
def reverseNum(n, rem=0):
   if n == 0:
      return (rem)//10
   else:
      return reverseNum(n//10, (rem+(n%10))*10)

print(reverseNum(7165))
print(reverseNum(123456789))

Peu modifiée version:

def reverseNum(n, rem=0):
    if n == 0:
        return rem
    elif n<10:
        return reverseNum(n//10, (rem+(n%10)))
    else:
        return reverseNum(n//10, (rem+(n%10))*10)

print(reverseNum(7165))
print(reverseNum(123456789))

InformationsquelleAutor Jayant

def reverse_num_RECUR(num):

    if num<10:
        return num
    else:
        # print(str(num%10))
        return  (str(num%10)+str(reverse_num_RECUR(num//10)))

print('see Reverse ',reverse_num_RECUR(410010699900012066))

InformationsquelleAutor Manoj Zade

-1

def reverseDisplay(variable):


        if variable // 10  == 0  : #base case
                print (variable, end='')
                return
        else:
                first = variable % 10
                every_dig_after = variable // 10 
                return reverseDisplay (variable % 10 )   ,  reverseDisplay(every_dig_after) 




def main():
        number = int (input ( "Enterr a number:"))
        reverseDisplay(number)

main()

InformationsquelleAutor user4301398

-2
```
def reverseDisplay(number):
   if number<10:
      return number 
   else:
      return reverseDisplay(number//10) + number # you forgot add me
```
- Cela nous laisse avec reverseDisplay(91) => 100. droit...
- mais qui retourne une valeur incorrecte c'est à dire d'entrée est de 123 et la sortie est 3136.
- Ce n'est pas correct du tout.
InformationsquelleAutor Tao Peng

Vous devez vous connecter pour publier un commentaire.