Отслеживайте, сколько раз была вызвана рекурсивная функция

 function singleDigit(num) {
      let counter = 0
      let number = [...num + ''].map(Number).reduce((x, y) => {return x * y})

      if(number <= 9){
          console.log(number)
      }else{
          console.log(number)
          return singleDigit(number), counter += 1
      }
   }
singleDigit(39)

Приведенный выше код принимает целое число и сводит его к одной цифре, умножая его на свои собственные цифры.

Пример 39

3 x 9 = 27.
2 x 7 = 14.
1 x 4 = 4.

Консоль будет регистрировать:

27 
14 
4

Как отследить, чтобы рекурсивная функция была вызвана 3 раза?

Я попытался добавить счетчик, но он не обновляется. Буду признателен за любую помощь

Это почти чисто академический вариант, но для этой цели вы можете использовать модифицированный комбинатор с фиксированной точкой .

Позволяет немного сократить и улучшить исходную функцию:

function singleDigit(n) {
    let digitProduct = [...(n + '')].reduce((x, y) => x * y, 1);
    return digitProduct <= 9 ? digitProduct : singleDigit(digitProduct);
}

// singleDigit(123234234) == 0

Из этого варианта мы можем выделить и вывести рекурсивный вызов:

function singleDigitF(recur) {
    return function (n) {
        let digitProduct = [...(n + '')].reduce((x, y) => x * y, 1);
        return digitProduct <= 9 ? digitProduct : recur()(digitProduct);
    };
}

Эта функция теперь может использоваться с комбинатором с фиксированной точкой; в частности, я реализовал Y-комбинатор, адаптированный для (строгого) JavaScript, следующим образом:

function Ynormal(f, ...args) {
    let Y = (g) => g(() => Y(g));
    return Y(f)(...args);
}

где у нас есть Ynormal(singleDigitF, 123234234) == 0.

Теперь приходит хитрость. Поскольку мы вычеркнули рекурсию к Y-комбинатору, мы можем посчитать количество рекурсий в нем:

function Ycount(f, ...args) {
    let count = 1;
    let Y = (g) => g(() => {count += 1; return Y(g);});
    return [Y(f)(...args), count];
}

Быстрая проверка в узле REPL дает:

> Ycount(singleDigitF, 123234234)
[ 0, 3 ]
> let digitProduct = (n) => [...(n + '')].reduce((x, y) => x * y, 1)
undefined
> digitProduct(123234234)
3456
> digitProduct(3456)
360
> digitProduct(360)
0
> Ycount(singleDigitF, 39)
[ 4, 3 ]

Этот комбинатор теперь будет работать для подсчета количества вызовов в любой рекурсивной функции, написанной в стиле singleDigitF.

(Обратите внимание, что есть два источника получения нуля в качестве очень частого ответа: числовое переполнение ( 123345456999999999становление 123345457000000000и т. Д.) И тот факт, что вы почти наверняка получите ноль в качестве промежуточного значения где-то, когда размер входных данных увеличивается.)

Вы должны добавить встречный аргумент в определение вашей функции:

function singleDigit(num, counter = 0) {
    console.log(`called ${counter} times`)
    //...
    return singleDigit(number, counter+1)
}
singleDigit(39)

Традиционное решение состоит в том, чтобы передать счет в качестве параметра функции, как это предлагается в другом ответе.

Тем не менее, есть другое решение в JS. Несколько других ответов предложили просто объявить count вне рекурсивной функции:

let counter = 0
function singleDigit(num) {
  counter++;
  // ..
}

Это конечно работает. Однако это делает функцию не входящей (не может быть вызвана дважды правильно). В некоторых случаях вы можете игнорировать эту проблему и просто убедиться, что вы не вызываете singleDigitдважды (javascript является однопоточным, так что это не так уж сложно сделать), но это ошибка, ожидающая того, что произойдет, если вы обновитесь singleDigitпозже, чтобы стать асинхронной, и она также чувствует некрасиво.

Решение состоит в том, чтобы объявить counterпеременную снаружи, но не глобально. Это возможно, потому что у javascript есть замыкания:

function singleDigit(num) {
  let counter = 0; // outside but in a closure

  // use an inner function as the real recursive function:
  function recursion (num) {
    counter ++
    let number = [...num + ''].map(Number).reduce((x, y) => {return x * y})

    if(number <= 9){
      return counter            // return final count (terminate)
    }else{
      return recursion(number)  // recurse!
    }
  }

  return recursion(num); // start recursion
}

Это похоже на глобальное решение, но каждый раз, когда вы вызываете singleDigit(которая теперь не является рекурсивной функцией), оно будет создавать новый экземпляр counterпеременной.

Другой подход, поскольку вы производите все числа, заключается в использовании генератора.

Последний элемент - это ваше число, nуменьшенное до однозначного числа, и чтобы подсчитать, сколько раз вы повторяли, просто прочитайте длину массива.

const digits = [...to_single_digit(39)];
console.log(digits);
//=> [27, 14, 4]

<script>
function* to_single_digit(n) {
  do {
    n = [...String(n)].reduce((x, y) => x * y);
    yield n;
  } while (n > 9);
}
</script>

Последние мысли

Возможно, вы захотите рассмотреть возможность возврата в свое состояние. Все номера с нулем в нем будет возвращать ноль.

singleDigit(1024);       //=> 0
singleDigit(9876543210); //=> 0

// possible solution: String(n).includes('0')

То же самое можно сказать и о любых числах, состоящих 1только из.

singleDigit(11);    //=> 1
singleDigit(111);   //=> 1
singleDigit(11111); //=> 1

// possible solution: [...String(n)].every(n => n === '1')

Наконец, вы не уточнили, принимаете ли вы только положительные целые числа. Если вы принимаете отрицательные целые числа, приведение их к строкам может быть рискованным:

[...String(39)].reduce((x, y) => x * y)
//=> 27

[...String(-39)].reduce((x, y) => x * y)
//=> NaN

Возможное решение:

const mult = n =>
  [...String(Math.abs(n))].reduce((x, y) => x * y, n < 0 ? -1 : 1)

mult(39)
//=> 27

mult(-39)
//=> -27

Здесь было много интересных ответов. Я думаю, что моя версия предлагает дополнительную интересную альтернативу.

Вы делаете несколько вещей с вашей требуемой функцией. Вы рекурсивно сводите его к одной цифре. Вы записываете промежуточные значения, и вам нужно подсчитать количество рекурсивных вызовов. Один из способов справиться со всем этим - написать чистую функцию, которая будет возвращать структуру данных, содержащую конечный результат, выполненные шаги и количество вызовов в одном:

  {
    digit: 4,
    steps: [39, 27, 14, 4],
    calls: 3
  }

Затем вы можете записать шаги, если хотите, или сохранить их для дальнейшей обработки.

Вот версия, которая делает это:

const singleDigit = (n, steps = []) =>
  n <= 9
    ? {digit: n, steps: [... steps, n], calls: steps .length}
    : singleDigit ([... (n + '')] .reduce ((a, b) => a * b), [... steps, n])

console .log (singleDigit (39))

Обратите внимание, что мы отслеживаем, stepsно выводим calls. Хотя мы могли бы отслеживать количество вызовов с помощью дополнительного параметра, это, похоже, ничего не дает. Мы также пропускаем map(Number)шаг - они будут приведены к числам в любом случае умножением.

Если у вас есть опасения по поводу того, что этот stepsпараметр по умолчанию выставлен как часть вашего API, его достаточно легко скрыть с помощью внутренней функции, подобной этой:

const singleDigit = (n) => {
  const recur = (n, steps) => 
    n <= 9
      ? {digit: n, steps: [... steps, n], calls: steps .length}
      : recur ([... (n + '')] .reduce ((a, b) => a * b), [... steps, n])
  return recur (n, [])
}

И в любом случае, было бы немного чище извлечь умножение цифр в вспомогательную функцию:

const digitProduct = (n) => [... (n + '')] .reduce ((a, b) => a * b)

const singleDigit = (n, steps = []) =>
  n <= 9
    ? {digit: n, steps: [... steps, n], calls: steps .length}
    : singleDigit (digitProduct(n), [... steps, n])

Если вы просто пытаетесь подсчитать, сколько раз оно уменьшается, и не заботитесь о рекурсии конкретно ... вы можете просто удалить рекурсию. Приведенный ниже код остается верным Исходному сообщению, поскольку он не считается num <= 9нуждающимся в сокращении. Следовательно, singleDigit(8)будет иметь count = 0и singleDigit(39)будет count = 3, так же, как OP и принятый ответ демонстрируют:

const singleDigit = (num) => {
    let count = 0, ret, x;
    while (num > 9) {
        ret = 1;
        while (num > 9) {
            x = num % 10;
            num = (num - x) / 10;
            ret *= x;
        }
        num *= ret;
        count++;
        console.log(num);
    }
    console.log("Answer = " + num + ", count = " + count);
    return num;
}

Нет необходимости обрабатывать числа 9 или меньше (т.е. num <= 9). К сожалению, код OP будет обрабатываться, num <= 9даже если он его не считает. Код выше не будет ни обрабатывать, ни считать num <= 9. Это просто проходит через.

Я предпочитаю не использовать, .reduceпотому что выполнение математики выполнялось намного быстрее. И, для меня, легче понять.

Дальнейшее размышление о скорости

Я чувствую, хороший код тоже быстро. Если вы используете этот тип сокращения (который часто используется в нумерологии), вам может понадобиться использовать его для огромного количества данных. В этом случае скорость станет самым важным.

Использование обоих .map(Number)и console.log(на каждом этапе сокращения) очень и очень долго для выполнения и не нужно. Простое удаление .map(Number)из OP ускорило его примерно в 4,38 раза. Удаление console.logускорило его настолько, что было почти невозможно правильно протестировать (я не хотел ждать этого).

Так что , похоже на customcommander ответ «s, не используя .map(Number)ни console.logи толкающие результаты в массив и использовать .lengthдля countгораздо гораздо быстрее. К сожалению для ответа customcommander , использование функции генератора действительно очень медленно (этот ответ примерно в 2,68 раза медленнее, чем OP без .map(Number)и console.log)

Кроме того, вместо использования .reduceя просто использовал фактическую математику. Это единственное изменение ускорило мою версию функции в 3,59 раза.

Наконец, рекурсия медленнее, она занимает место в стеке, использует больше памяти и имеет ограничение на количество повторений. Или, в этом случае, сколько шагов сокращения он может использовать, чтобы завершить полное сокращение. Развертывание рекурсии в итеративных циклах сохраняет все это в одном и том же месте в стеке и не имеет теоретического ограничения на количество шагов сокращения, которое можно использовать для завершения. Таким образом, эти функции здесь могут «уменьшить» почти любое целое число, ограниченное только временем выполнения и продолжительностью массива.

Все это в виду ...

const singleDigit2 = (num) => {
    let red, x, arr = [];
    do {
        red = 1;
        while (num > 9) {
            x = num % 10;
            num = (num - x) / 10;
            red *= x;
        }
        num *= red;
        arr.push(num);
    } while (num > 9);
    return arr;
}

let ans = singleDigit2(39);
console.log("singleDigit2(39) = [" + ans + "],  count = " + ans.length );
 // Output: singleDigit2(39) = [27,14,4],  count = 3

Вышеуказанная функция работает очень быстро. Это примерно в 3,13 раза быстрее, чем OP (без .map(Number)и console.log), и примерно в 8,4 раза быстрее, чем ответ customcommander . Имейте в виду, что удаление console.logиз OP предотвращает создание числа на каждом шаге сокращения. Следовательно, здесь необходимо поместить эти результаты в массив.

PT

Почему бы не сделать вызов console.countв вашей функции?

Изменить: фрагмент, чтобы попробовать в вашем браузере:

function singleDigit(num) {
    console.count("singleDigit");

    let counter = 0
    let number = [...num + ''].map(Number).reduce((x, y) => {return x * y})

    if(number <= 9){
        console.log(number)
    }else{
        console.log(number)
        return singleDigit(number), counter += 1
    }
}
singleDigit(39)

У меня это работает в Chrome 79 и Firefox 72

Вы можете использовать закрытие для этого.

Просто храните counterв закрытии функции.

Вот пример:

function singleDigitDecorator() {
	let counter = 0;

	return function singleDigitWork(num, isCalledRecursively) {

		// Reset if called with new params 
		if (!isCalledRecursively) {
			counter = 0;
		}

		counter++; // *

		console.log(`called ${counter} times`);

		let number = [...(num + "")].map(Number).reduce((x, y) => {
			return x * y;
		});

		if (number <= 9) {
			console.log(number);
		} else {
			console.log(number);

			return singleDigitWork(number, true);
		}
	};
}

const singleDigit = singleDigitDecorator();

singleDigit(39);

console.log('`===========`');

singleDigit(44);

Вот версия Python, которая использует функцию-обертку для упрощения счетчика, как было предложено в ответе slebetman - я пишу это только потому, что основная идея очень ясна в этой реализации:

from functools import reduce

def single_digit(n: int) -> tuple:
    """Take an integer >= 0 and return a tuple of the single-digit product reduction
    and the number of reductions performed."""

    def _single_digit(n, i):
        if n <= 9:
            return n, i
        else:
            digits = (int(d) for d in str(n))
            product = reduce(lambda x, y: x * y, digits)
            return _single_digit(product, i + 1)

    return _single_digit(n, 0)

>>> single_digit(39)
(4, 3)