整数切片吊索的任何替代项

Question

我正在尝试创建一个递归函数，将最后两个数字相加，直到没有剩余的数字。例如：

sumDigits(239)

相当于：

2+3+9=14

这很困难，因为输入必须是整数，如果不转换它就无法切片。我决定尝试将其转换为列表，因为我认为 pop(( 方法对此很有用。这种方法似乎行不通。有什么建议吗？

执行：

>>> sumDigits('234')
9
>>> sumDigits('2343436432424')
8
>>> 

法典：

def sumDigits(n):
    l1 = list(str(n))
    if len(l1) > 1:
        a = int(l1.pop())
        b = int(l1.pop())
        l1.append(str(a+b))
        return sumDigits(int(''.join(l1)))
    else:
        return n

Answer 1

使用像reduce()这样的功能工具，问题由

from functools import reduce
def sumDigits(n):
    return reduce((lambda x, y: int(x) + int(y)), list(str(n)))

Answer 2

与其传递字符串，不如传递整数列表：

def sumDigits(l1):
    if len(l1) > 1:
        a = l1.pop()
        b = l1.pop()
        l1.append(a+b)
        return sumDigits(l1)
    else:
        return l1[0]
print sumDigits([2,3, 4])
print sumDigits([2, 3, 4, 3,  4, 3, 6, 4, 3, 2, 4, 2, 4])

您的方法的问题在于：

'23434364324|24|' -> '2343436432|46|' -> '2343436432 | 10' ，

现在在这里，pop 将返回 0 和 1 ，而不是您期望的2和10。因此输出错误。

简单的解决方案：

>>> s = '2343436432424'
>>> sum(int(x) for x in s)
44

Answer 3

由于每个人似乎都打算为您解决家庭作业，因此这里有一个优雅的递归解决方案。

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

Answer 4

编辑

简单的解决方案是：

def sumDigits(n):
    return sum(int(i) for i in str(n))

在您回答我的评论后，以下解决方案不适用。

def sumDigits(n):
    n = [int(i) for i in str(n)]
    return sumDigitsRec(n)
def sumDigitsRec(li):
    if len(li) > 1:
        li[-1] += li.pop()
        return sumDigits(''.join(str(i) for i in li))
    else:
        return li[0]

Answer 5

作为字符串：

def sumDigits(n):
    answer = 0
    for num in n:
        answer += int(num)
    return answer

不进行切片，仅使用整数输入：

def sumDigits(n):
    answer = 0
    while n:
        answer += n%10
        n /= 10
    return answer

Answer 6

如果我正确理解您的问题，您希望在总和为 2 位数字时停止对数字求和。我认为您的程序中的错误是您无需if len(l1) > 2: if len(l1) > 1:以确保在只有 2 位数字时不会递归。

Answer 7

你可以这样递归地做到这一点：

def sumDigits(n,s=0):
    if len(n) == 0:
        return s
    else:
        return sumDigits(n[:-1],s+int(n[-1]))

如果你想要更简单和pytonic的方式(不是递归的(，你可以这样做

>>> s = 2343436432424
>>> sum(map(int,str(s)))
44

Answer 8

提供的所有解决方案都未能满足问题描述中所述的先决条件。这是正确答案：

使用 **kwargs 和异常在递归函数中使用保持变量。

例如：

def recursionFunc(x, **kwargs):
    try:
        count = kwargs['count']
    except:
        count = 0
        #Code down here to add num from x to count
        #remove last index on every iteration from x
        #etc
    return recursionFunc(x, count = count)

Answer 9

它工作正常，如以下检查所示：

>>> 2343436432424 % 9
8

如果您不是故意递归调用它，那么请不要这样做，即停止检查长度并返回总和。