Вычитание двух рекурсивных кортежей

Я пишу калькулятор произвольной точности и связываю, чтобы написать функцию, которая вычитает два вложенных кортежа.

Кортежи представлены в виде:
Для числа 12345 Кортеж будет выглядеть так (1,(2,(3,(4,(5, ())))))

Это моя функция. Он использует функцию, которая возвращает кортеж с большим значением и функцией полезности для доступа к элементам и поиска длины кортежа.

def subtractLists(list1, list2):
    borrow = 0
    result = ()
    larger = findLargerValue(list1,list2)
    smaller = list2 if larger != list2 else list1
    index1 = len_rlist(larger)-1
    index2 = len_rlist(smaller)-1
    nonzero = 0
    while index1 >= 0 and index2 >= 0:
        item1 = getitem_rlist(larger, index1)
        item2 = getitem_rlist(smaller, index2)


        if index1 == nonzero:
            borrow = 0
            item1 -= 1
        if item1 >= item2:
            result = makeRlist(borrow + item1 - item2, result)
            index1 -= 1
            index2 -= 1
        else:
            newindex = index1-1
            while getitem_rlist(larger, newindex) == 0 and newindex >= 0:
                newindex -= 1
            nonzero = newindex
            result = makeRlist(10 + item1 - item2)
            borrow = 9
            index1 -= 1
            index2 -= 1

    return result

Если я применяю эту функцию к спискам, представляющим числа 12345 и 999, выход будет:

12345-999 = (6,None)

Вот makeRlist:

def first(s):
    """Return the first member of the recursive list"""
    return s[0]
def rest(s):
    """Return the second member, which is the rest of the recursive list"""
    return s[1]
def makeRlist(first,rest=None):
    """Create a recursive list"""
    return (first,rest)

1 ответ

  1. Это то, что тебе нужно ?

    toRecursiveList преобразует число в кортеж в кортеж в кортеж…

    recursiveSubstract рекурсивно вычитает каждое число и в конечном итоге сохраняет единицу, когда она сталкивается с отрицательными числами.

    getDepth возвращает глубину кортежа (длину числа)

    substract метод, который вы вызываете, чтобы сделать подстроку с помощью двух чисел, он будет заполнять tinyest с нулями, так что теперь номера имеют тот же размер.

    def toRecursiveList(n, i = 0):
      return (int(str(n)[i]), toRecursiveList(n, i + 1)) if i < len(str(n)) else ()
    
    def recursiveSubstract(l1, l2):
      tuple, toRet = (), 0
      if l1 != () and l2 != ():
        sub = l1[0] - l2[0]
        if l1[0] - l2[0] < 0: sub, toRet = sub + 10, 1
        next, ret = recursiveSubstract(l1[1], l2[1])
        tuple = (sub - ret, next)
      return tuple, toRet
    
    def getDepth(l, i = 1):
      return getDepth(l[1], i + 1) if l[1] != () else i
    
    def substract(n1, n2):
      l1, l2 = toRecursiveList(max(n1, n2)), toRecursiveList(min(n1, n2))
      while getDepth(l1) > getDepth(l2): l2 = (0, l2)
      return recursiveSubstract(l1, l2)[0]
    
    print(substract(12345, 999))