Coding Challenge, пытаюсь решить рекурсивно.помощь по кешированию с помощью Closure

Question

вопрос: / Операция step (x) работает следующим образом: она меняет число x на x - s (x), где s (x) - сумма цифр x.// Вам нравится применять функции к числам, поэтому, учитывая число n, вы решаете построить убывающую последовательность чисел: n, step (n), // step (step (n)) и т. Д., С 0 в качестве последнегоelement.

// Построение одной последовательности недостаточно для вас, поэтому вы заменяете все элементы последовательности суммами их цифр (s (x)).// Теперь вам интересно, какой номер чаще всего появляется в новой последовательности.Если существует несколько ответов, вернуть максимальный.

// Пример

// - Для n = 88 вывод должен быть // mostFrequentDigitSum (n)= 9.

// Вот первая построенная вами последовательность: 88, 72, 63, 54, 45, 36, 27, 18, 9, 0;

// А вотs (x) для каждого из его элементов: 16, 9, 9, 9, 9, 9, 9, 9, 9, 0.

// Как видите, наиболее частое число во второмпоследовательность равна 9.

// - Для n = 8 вывод должен быть // mostFrequentDigitSum (n) = 8.

// Сначала вы построили следующую последовательность: 8, 0

// s (x) для каждого из его элементов: 8, 0

// Как видите, ответ равен 8 (он появляется так же часто, как 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);

Я создал объект, используя рекурсию.Мне пришлось создать глобальную переменную для моего кеша, и я хочу, чтобы мой код был автономным.Я пытался сделать несколько вещей, чтобы заставить его работать как закрытие, но все еще не нашел решение.Любые советы будут полезны. Поскольку я пытаюсь стать лучше в рекурсии, если есть другой способ решить это рекурсивно, я бы не стал смотреть на код других людей.Заставить мою работу рекурсивно и в замкнутом пространстве тоже было бы очень полезно.Спасибо.

Answer 1

Вы можете recursiveCall принять второй параметр, cache, который по умолчанию равен {}.

function recursiveCall(x, cache = {}) {
  if (x == 0) {
    return cache;
  }
  // ...
  return recursiveCall(x - sumOfX, cache);
}

При первом вызове recursiveCall объект cache будетсоздано;при последующих рекурсивных вызовах recursiveCall вы можете передать этот объект в качестве второго параметра.Когда вы достигнете конца рекурсии, return cache, чтобы она вернулась к начальному вызову:

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

И затем вы можете использовать эту переменную cache для вычисления возвращаемого valueот mostFrequentDigitSum.cache теперь не глобален, он создается заново каждый раз, когда вызывается mostFrequentDigitSum (или, точнее, каждый раз, когда recursiveCall вызывается извне).

function recursiveCall(x, cache = {}) {
  if (x == 0) {
    return cache;
  }
  //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]++;
  }
  return recursiveCall(x - sumOfX, cache);
}



function mostFrequentDigitSum(digit) {
  //create our cache using our recursive call
  const cache = 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));

Или, чтобы урезать ваш код, сохраняя ту же логику:

function recursiveCall(x, cache = {}) {
  if (x === 0) {
    return cache;
  }
  const sumOfX = x.toString().split('').map(Number).reduce((a, b) => a + b, 0);
  cache[sumOfX] = (cache[sumOfX] || 0) + 1;
  return recursiveCall(x - sumOfX, cache);
}

function mostFrequentDigitSum(digit) {
  //create our cache using our recursive call
  const cache = recursiveCall(digit);
  //find the largest value in that object.
  return Object.entries(cache).reduce((a, b) => a[1] > b[1] ? a : b, [null, 0])[0];
}
console.log(mostFrequentDigitSum(88));
console.log(mostFrequentDigitSum(8));
console.log(mostFrequentDigitSum(0));