Javascript 编码挑战，尝试递归求解。关于使用闭包缓存的帮助

问题是： /stepx操作的工作原理如下：它将数字x更改为x-sx，其中sx是x的数字之和。 //您喜欢将函数应用于数字，因此给定数字n，您决定构建一个递减的数字序列：n，stepn， //stepn等，最后一个元素为0

//构建单个序列对您来说是不够的，因此您可以用序列中的所有元素的数字sx之和替换它们。 //现在，您很好奇新序列中最常出现的是哪个数字。如果有多个答案，请返回最大的一个

//范例

//-对于n=88，输出应为 //mostFrequentDigitSumn=9

//这是您构建的第一个序列：88、72、63、54、45、36、27、18、9、0

//这里是每个元素的sx:16，9，9，9，9，9，9，9，9，9，9，0

//如您所见，第二个序列中最常见的数字是9

//-对于n=8，输出应为 //mostFrequentDigitSumn=8

//首先，您构建了以下序列：8，0

//每个元素的sx为：8，0

//如您所见，答案是8，它经常显示为0，但大于0

所以我看了这个问题，这里递归似乎很好。我确信有一种更简单的迭代方法，但我也在尝试更好地使用递归，所以我尝试使用递归

let cache = {}

function recursiveCall ( x ) {
    if( x == 0 ) { return 'dog' } // we dont need to return anything, because after each recursive call we are saving cache[sumOfX] in our cache,
    //once we get to the very TOP of our stack when it hit 0.  We have already made our object, and therefore do not even need a return statement.


    //get the sum of our digits for x.
    let sumOfX = x.toString().split('').map( n => { return Number(n)}).reduce( (sum, num) => {
        sum += num;
        return sum;
    },0);

    //creates a key for a sumOfX and makes the value 1 if it hasnt been seen or increments the value if it has been seen.
    if( !cache[sumOfX] ) {
        cache[sumOfX] = 1;
    } else {
        cache[sumOfX]++;
    }



    console.log(x);
    console.log(sumOfX);
    recursiveCall( x - sumOfX );
    console.log(cache)
}



function mostFrequentDigitSum( digit ) {
//create our cache using our recursive call
recursiveCall(digit);

//find the largest value in that object.
let max = 0;
let value = 0;
for(var key in cache) {
    if( max < cache[key]) {
        max = cache[key];
        value = Number(key);
    }
}
return value;
}


console.log(mostFrequentDigitSum(88));

console.log(cache);

我使用递归创建了一个对象。不过，我必须为缓存创建一个全局变量，我希望我的代码是自包含的。我试着做了一些事情，使它作为一个结束工作，但仍然没有想出一个解决办法。任何提示都会很有帮助，因为我正试图在递归方面做得更好，如果有其他方法可以递归地解决这个问题，我不会看别人的代码。让我的工作在一个自我封闭的循环中也会很有帮助。谢谢。

您可以让recursiveCall接受第二个参数cache，默认为{}

在第一次调用recursiveCall时，将创建缓存对象；在对recursiveCall的后续递归调用中，可以将该对象作为第二个参数传递。当到达递归结束时，返回缓存，使其返回到初始调用：

function mostFrequentDigitSum(digit) {
  //create our cache using our recursive call
  const cache = recursiveCall(digit);

然后，您可以使用该缓存变量来计算从mostFrequentDigitSum返回的值。缓存现在不是全局的，每次调用mostFrequentDigitSum时，或者更准确地说，每次外部调用recursiveCall时，都会重新创建缓存

函数recursiveCallx，cache={}{ 如果x==0{ 返回缓存； } //求x的数字之和。 让sumOfX=x.toString.split.mapn=>{ 返回编号 }.reducesum，num=>{ sum+=num； 回报金额； }, 0; //为sumOfX创建一个键，如果未看到该键，则将其值设为1；如果已看到该键，则将其值递增。 if！缓存[sumOfX]{ cache[sumOfX]=1； }否则{ 缓存[sumOfX]++； } 返回recursiveCallx-sumOfX，cache； } 函数mostFrequentDigitSumdigit{ //使用递归调用创建缓存 const cache=recursiveCalldigit； //查找该对象中的最大值。 设max=0； 设值=0； 对于缓存中的var键{ 如果最大值<缓存[键]{ max=缓存[键]； 数值=Numberkey； } } 返回值； } console.logmostFrequentDigitSum88；

function mostFrequentDigitSum(digit) {
  //create our cache using our recursive call
  const cache = recursiveCall(digit);