我们有一组排序的数字 D，它是  {'1','2','3','4','5','6','7','8','9'} 的非空子集。（请注意，'0'不包括在内。）

现在，我们用这些数字进行组合写数字，想用多少次就用多少次。例如 D = {'1','3','5'}，我们可以写出像 '13', '551', '1351315' 这样的数字。

返回可以用 D 中的数字写出的小于或等于 N 的正整数的数目。

示例 1：

输入：D = ["1","3","5","7"], N = 100
输出：20
解释：
可写出的 20 个数字是：
1, 3, 5, 7, 11, 13, 15, 17, 31, 33, 35, 37, 51, 53, 55, 57, 71, 73, 75, 77.

示例 2：

输入：D = ["1","4","9"], N = 1000000000
输出：29523
解释：
我们可以写 3 个一位数字，9 个两位数字，27 个三位数字，
81 个四位数字，243 个五位数字，729 个六位数字，
2187 个七位数字，6561 个八位数字和 19683 个九位数字。
总共，可以使用D中的数字写出 29523 个整数。

提示：

1. D 是按排序顺序的数字 '1'-'9' 的子集。
2. 1 <= N <= 10^9

思路:

一开始想直接用递归，不断加数字，小于等于N就让count++，结果发现超时，说明算法太慢了。

比赛结束后，参考了其他选手的答案，也要用递归，只不过在组合小于N的位数的数字时，不需要用递归，而是直接求D的数字个数的幂次方即可。

例如：
输入：D = ["1","3","5","7"], N = 100

对于一位数，有4的1次方个数，即4
对于两位数，有4的2次方个数，即16，
而无法组成比100小的三位数，因此结果为 4 + 16 = 20

所以难点在于如何取到与N相同位数的数字。

具体做法是，先将D和N都转换成以数字为元素的数组，例如

D = [1,3,5,7]
N = [1,0,0]

递归函数接受两个参数，D和N，表示用D组成与N相同位数的数字的个数，在函数中，遍历D，判断与N[0]的关系：

若d大于N[0]，说明不能以d开头，break；

若d等于N[0]，说明可以以d开头，但是还得继续判断后续其他数字，于是就要递归调用了；

若d小于N[0]，说明只要以d开头，就都满足，所以是D长度的（N-1)长度次方。

若N的长度为0，说明这里已经递归到个位数了，返回1。

/**
 * @param {string[]} D
 * @param {number} N
 * @return {number}
 */
var atMostNGivenDigitSet = function(D, N) {
  let count = 0,
      lenD = D.length,
      numD = [];
  for (let d of D) numD.push(parseInt(d));    // numD: [1,3,5,7]
  
  let arrN = N.toString().split('')
  let numN = [];
  for (let n of arrN) numN.push(parseInt(n));   // numN: [1,0,0]
  
  for (let i = 1, l = arrN.length; i < l; i++) {    // 当位数小于N的位数时，直接是D的个数的幂次方
    count += Math.pow(lenD, i)
  }
  
  const recursion = (numD, numN) => {
    if (!numN.length) return 1
    let count = 0
    for (let num of numD) {
      if (num > numN[0]) break
      else if (num === numN[0]) {
        count += recursion(numD, numN.slice(1));
      } else {
        count += Math.pow(numD.length, (numN.length-1));
      }
    }
    return count
  }
  
  return count + recursion(numD, numN)
};