Vermeidung von String + Ganzzahladdition bei Verwendung der rekursiven Funktion

Question

Ich versuche eine Funktion (die Funktionsrekursion verwendet) zu erstellen, die eine Zahl, n, sucht nach einer Ziffer d, & Wenn ich d durch ersetzen möchte eine bestimmte Zahl r, wie im folgenden Code gezeigt. Dieser Code funktioniert gut, aber die Ausgabe ist in einem String-Format. Ich habe viele Möglichkeiten ausprobiert, um es zu ändern, um eine ganze Zahl auszugeben, aber ohne Erfolg. Danke für die Hilfe!

def replace_digit(n, d, r): 
    number = str(n) 
    i = 0 
    if len(number) == 1: 
     if number == str(d): 
      return str(r) 
     else: 
      return number 
    else: 
     if number[i] == str(d): 
      return number[:i] + str(r) + replace_digit(int(number[i+1:]),d,r) 
     else: 
      return number[i] + replace_digit(int(number[i+1:]),d ,r) 

Answer 1

Es ist ziemlich einfach, aber Sie müssen einige Typkonvertierungen zwischen str und int:

def replace_digit(n, d, r): 
    number = str(n) 
    rest = str(replace_digit(int(number[1:]), d, r)) if len(number) > 1 else "" 
    digit = number[0] 
    digit = str(r) if digit == str(d) else digit 
    return int(digit + rest) 

Es gibt auch eine andere Möglichkeit, einen Wrapper verwenden. Dies begrenzt die Anzahl der Typumwandlungen.

def replace_digit(n, d, r): 
    def replace(n, d, r): 
     rest = replace(n[1:], d, r) if len(n) > 1 else "" 
     return r + rest if n[0] == d else n[0] + rest 

    return int(replace(str(n), str(d), str(r))) 

Answer 2

Wenn Sie bereits eine funktionierende Funktion haben, warum nicht einfach das Problem aufteilen?

def replace(n, d, r): 
    def replace_digit(n, d, r): # doesn't change 
     return ... 
    return int(replace_digit(str(n), str(d), str(r)) 

Answer 3

Die Lösung ist den Rückgabewert mit int() wickelt wie bereits in den Kommentaren und anderen Antworten erwähnt wurde.

Aber hier ist eine Version, die String-Manipulation überhaupt nicht verwendet. Nur zum Spaß.

def replace_digit(n, d, r): 
    rest = n // 10 # all but the rightmost digit 
    digit = n - rest * 10 # only the rightmost digit 
    digit = r if digit == d else digit 
    if rest == 0: 
     return digit 

    return replace_digit(rest, d, r) * 10 + digit 

Answer 4

Stattdessen wird die Verkettung versuchen, diese zurückzugeben:

if number[i] == str(d): 
    new_number = number[:i] + str(r) + replace_digit(int(number[i+1:]),d,r) 
else: 
    new_number = number[i] + replace_digit(int(number[i+1:]),d ,r) 

return int(new_number) 

Answer 5

def replace_digit(number, digit, replacement): 

    if number == 0: 
     return number # base case 

    quotient, remainder = divmod(number, 10) 

    if remainder == digit: 
     remainder = replacement 

    return replace_digit(quotient, digit, replacement) * 10 + remainder 


print(replace_digit(961748941982451653, 9, 2)) 

OUTPUT

261748241282451653