Слідкуйте за тим, скільки разів викликалася рекурсивна функція

 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 є ще одне рішення. Кілька інших відповідей пропонують просто оголосити кількість за межами рекурсивної функції:

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, як і ОП та прийнята відповідь демонструють:

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)з ОП скоротило його приблизно на 4.38 разів. Видаливши console.logйого так швидко, майже неможливо було правильно перевірити (я не хотів його чекати).

Таким чином, подібно до відповіді customcommander , не використовувати .map(Number)ні console.logі не виштовхувати результати в масив і використовувати .lengthдля countнабагато набагато швидше. На жаль для відповіді customcommander , використання функції генератора дійсно дуже повільне (ця відповідь приблизно на 2.68x повільніше, ніж OP без .map(Number)і console.log)

Крім того, замість використання .reduceя просто використав фактичну математику. Сама ця зміна прискорила мою версію функції в 3,5 раза.

Нарешті, рекурсія проходить повільніше, вона займає простір у стеці, використовує більше пам’яті та обмежує кількість разів, коли вона може «повторюватися». Або, у цьому випадку, скільки кроків зменшення він може використати для завершення повного зменшення. Розгортання вашої рекурсії до ітеративних циклів зберігає це все на тому самому місці стека і не має теоретичного обмеження, скільки кроків зменшення може використовувати для завершення. Таким чином, ці функції тут можуть «зменшити» майже будь-яке розмірне ціле число, лише обмежене часом виконання та тим, наскільки тривалим може бути масив.

Все це на увазі ...

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 рази швидше, ніж ОП (без .map(Number)і console.log) і приблизно в 8,4 рази швидше, ніж відповідь користувача. Майте на увазі, що видалення console.logз ОП не дозволяє йому створювати число на кожному кроці скорочення. Отже, необхідність просунути ці результати в масив.

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)