leetcode 648 位数求和: 所有的长度为n的数中，各个位上的数字之和为m的这些数的和是多少呢。给定n和m，求这些数的和。python

NC648 位数求和
题目描述: 所有的长度为n的数中，各个位上的数字之和为m的这些数的和是多少呢。给定n和m，求这些数的和。

示例1

输入

2,3

返回值

63

说明

12 + 21 +30 = 63
思路：两位数范围10-99，即10**(n-1)~10**n；

#
# 返回这样的数之和
# @param n int整型 数的长度
# @param m int整型 各个为之和
# @return long长整型
#思路：两位数范围10-99，即10**(n-1)~10**n；求和过程超时

class Solution:
    def sum(self , n , m ):
        # write code here
        n_sum=0
        for i in range(10**(n-1),10**n):
            tmp =i
            i_list =[j for j in str(i)]
            i_sum = sum(map(lambda x:int(x),i_list))
            if i_sum==m:
                n_sum += tmp
        return n_sum
sol=Solution()
sol.sum(2,3)           

#
# 返回这样的数之和
# @param n int整型 数的长度
# @param m int整型 各个为之和
# @return long长整型
#
class Solution:
    def sum(self , n , m ):
        # write code here
        s=0
        for i in range(10**(n-1),10**n):
            t=0
            tmp=i
            while i//10>0:
                t+=i%10
                i=i//10
            if t+i==m:
                s+=tmp
        return s
                
sol=Solution()
sol.sum(2,3)            

#
# 返回这样的数之和
# @param n int整型 数的长度
# @param m int整型 各个为之和
# @return long长整型
#
class Solution:
    def sum(self , n , m ):
        # write code here
        self.res = 0
        self.n = n
        self.m = m
        def dfs(cur, k):
            if k==0 and len(cur)==self.n:
                ans = 0
                n = len(cur)
                for i in range(n-1, -1, -1):
                    ans += cur[i]*(10**(n-i-1))
                self.res += ans
                return
            if len(cur)>=self.n:
                return
            for i in range(0, 10):
                if i>k or (len(cur)==0 and i==0):
                    continue
                cur.append(i)
                dfs(cur, k-i)
                cur.pop()
        dfs([], m)
        return self.res
sol=Solution()
sol.sum(2,3)  

#
# 返回这样的数之和
# @param n int整型 数的长度
# @param m int整型 各个为之和
# @return long长整型
#
class Solution:
    def sum(self , n , m ):
        # write code here
        self.res = 0
        def helper(t, digit_sum, res_sum):
            if t == n:
                if digit_sum == m:
                    self.res += res_sum
                return
            for i in range(10):
                if digit_sum == 0 and i == 0:
                    continue
                tmp = i + digit_sum
                if tmp > m:
                    break
                helper(t+1, digit_sum + i, res_sum*10+i)
        helper(0, 0, 0)
        return self.res
sol=Solution()
sol.sum(2,3)

#
# 返回这样的数之和
# @param n int整型 数的长度
# @param m int整型 各个为之和
# @return long长整型
#
class Solution:
    def sum(self , n , m ):
        self.res = 0
        def dfs(curPos, lastSum, curSum):
            if lastSum < 0:
                return
            if curPos == n:
                if lastSum == 0:
                    print(curSum)
                    self.res += curSum
                return
            for curDigit in range(10):
                if curPos == 0 and curDigit == 0:
                    continue
                dfs(curPos + 1, lastSum - curDigit, curSum * 10 + curDigit)
        dfs(0, m, 0)
        return self.res
sol=Solution()
sol.sum(2,3)

#
# 返回这样的数之和
# @param n int整型 数的长度
# @param m int整型 各个为之和
# @return long长整型
#
class Solution:
    def sum(self , n , m ):
        # write code here
        res = []

        def dfs(time: int, temp, res_sum):
            if time == n:
                if temp == m:
                    res.append(res_sum)
                return

            for i in range(10):
                if temp == 0 and i == 0:
                    continue
                tmp = i + temp
                if tmp > m:
                    break
                dfs(time + 1, temp + i, res_sum * 10 + i)

        dfs(0, 0, 0)
        return sum(res)
sol=Solution()
sol.sum(2,3)

#
# 返回这样的数之和
# @param n int整型 数的长度
# @param m int整型 各个为之和
# @return long长整型
#
from functools import lru_cache
@lru_cache(100000)
def F(r, k):
    if k == 1:
        if r < 10:
            return [[r]]
        else:
            return []
    res = []
    for i in range(min(10, r+1) ):
        for x in F(r-i, k-1):
            res.append([i]+x)
    return res


class Solution:
    def sum(self , n , m):
        ans = 0
        for l in F(m, n):
            if l[0] != 0:
                ans += int(''.join(map(str,l)))
        return ans


sol=Solution()
sol.sum(2,3)