Python-reverse-integer mit Rekursion

Arbeite ich an einem problem, das umkehren müssen einen integer-Eingabe ohne mit list oder string.
Aber mein Programm nur die ersten und die letzten Ziffern.

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()

Es scheint, wie die reverse-Funktion nur funktionierte nur einmal.

InformationsquelleAutor user1718826 | 2012-11-15

Sollte dies funktionieren:

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)

Könnte man auch reduzieren Sie die Anzahl der Zeiten, die Sie anrufen log10 und Anzahl der mathematischen Operationen mithilfe einer geschachtelten rekursiven Funktion:

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)))

Ihre Punkte in Bezug auf meine Lösung waren absolut vor Ort auf. Danke für den Hinweis!

InformationsquelleAutor John Gaines Jr.

1

Läuft es mehrere Male, aber es gibt nur die am weitesten Links stehende Ziffer. Es ist ziemlich leicht zu sehen, dass dies der Fall ist, wenn man bedenkt, unter welchen Umständen die if wahr werden.

Diese Arbeit zu machen, müssen Sie in den zahlen, die Sie übersprungen, wie Sie gehen aus der Rekursion. Die folgenden Werke, indem Sie einfach Heften Sie die übergebenen Ziffern Links von dem vorherigen Ergebnis. Ich würde lieber tun Sie es, ohne die string-Konvertierung, aber ich konnte nicht kommen mit einer eleganten Art und Weise zu tun, dass...
```
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

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

Hier ist, wie es funktioniert... (ich habe gekennzeichnet der Linien Im Bezugnahme auf hier)

Zeile 1: exit-Bedingung. Aber man weiß, das
Zeile 2: Holen Sie sich die Letzte Ziffer. % Mittel zu finden, die den Rest der division
Zeile 3: wenn Sie sagen, wir übergeben in der 123. An dieser Stelle haben wir first_digit=3 und the_rest=21. Wir wollen das Ergebnis 321 = 300 + 21. So ziemlich genau das, was wir brauchen, ist zu wissen, wie viele Male müssen wir mal first_digit von 10 für diese Arbeit
Zeile 4: mmm lecker

InformationsquelleAutor Sheena

Können Sie dies durch die Pflege eine extra Zahl, die Spur hält, wie viele Ziffern behandelt wurden bereits.

Diese kann getan werden, mit einem wrapper-Funktion:

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()

Die Idee ist, die Zähler zu behalten, wie viele nachgestellte Nullen hinzufügen, um die aktuelle Zahl zu machen, die neben der Arbeit.

Verfolgung durch diese wäre:

number = 1234

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

InformationsquelleAutor Aamir

0

Unter der Annahme, dass die Rekursion nicht verpflichtet war (immer eine gute Idee, Sie zu ersetzen durch iteration, wenn leicht möglich ist), schlage ich den folgenden code. Ich änderte den Namen der Funktion, für Klarheit und vermeiden Sie auch den overkill der Potenzierung und Logarithmus-Operationen in anderen Kommentaren.
```
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
```
aber er ist nicht gefragt für einen generator. Eine Antwort, die ZURÜCKGEGEBEN werden sollen
Mit ein paar änderungen, dies wäre eine viel bessere Lösung als meine. Ändern Sie einfach isinstance(n, int) isinstance(n, (int, long)) zu erlauben, es zu handhaben, beliebig lange zahlen, und gelten pep8 (4 Leerzeichen eingerückt). Es ist ca 4x schneller als bei meinem ersten und bis zu 2x schneller als meine zweite Lösung.

InformationsquelleAutor guidot
0

Edit: Das ist eine funktionierende Lösung.
```
def rev(x, prod=0):
    if x < 10:
        return prod + x
    else:
        prod = prod * 10 + x%10 * 10
        return rev(x / 10, prod)
```
Ergebnis:
```
>>> rev(123)
321
>>> rev(12345)
54321
>>> rev(72823780029)
92008732827L
>>> rev(1)
1
```
Der gepostete code funktioniert nicht. Für die Eingabe 123, in 2.7.3 gibt es 51 und in 3.3.0 gibt es ein apx. 54.23. Vielleicht ist Sie falsch gepostet-code als Ihrem Beispiel zu Antworten, verwenden Sie eine andere Funktion name?
Gaines Jr Behoben.

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)

Dies ist, was ich getan habe

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

Sollte dies funktionieren : geprüft auf Python ist3

# 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))

Wenig modifizierte 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
```
Das lässt uns mit reverseDisplay(91) => 100. richtig...
aber das würde einen falschen Wert zurückgeben, d.h. die Eingabe 123 ist, und die Ausgabe ist 3136.
Dies ist nicht korrekt.

InformationsquelleAutor Tao Peng

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.