跟踪调用递归函数的次数

Question

 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 次？

我已尝试添加计数器，但无法更新。 希望有任何帮助

Answer 1

您可以为此使用闭包。

只需将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);

Answer 2

为什么不在你的函数中调用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 中使用它

Answer 3

这是一个使用包装函数来简化计数器的 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)

Answer 4

这几乎是一个纯粹的学术变体，但您可以为此目的使用 modified fixed point combinator。

让我们稍微缩短和改进你原来的功能：

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

// singleDigit(123234234) == 0

从这个变体中，我们可以分解并curry递归调用：

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

此函数现在可以与定点组合器一起使用；具体来说，我实现了一个适用于（严格）JavaScript 的 Y 组合器，如下所示：

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];
}

快速检查 Node 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 ]

这个组合器现在将用于计算 any 以singleDigitF 样式编写的递归函数中的调用次数。

（请注意，作为一个非常常见的答案，有两个来源：数字溢出（123345456999999999 变为 123345457000000000 等），以及您几乎肯定会在某处得到零作为中间值的事实，当输入的大小正在增长。）

Answer 5

如果您只是想计算它减少了多少次并且不关心递归特别是...您可以删除递归。以下代码仍然忠实于原始帖子，因为它不将 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（在每个缩减步骤中）都非常耗时且不必要。只需从 OP 中删除 .map(Number) 即可将其加速约 4.38 倍。删除console.log 速度非常快，几乎不可能正确测试（我不想等待它）。

因此，类似于customcommander 的答案，不使用.map(Number) 或console.log 并将结果推送到数组中并为count 使用.length 要快得多。不幸的是，对于customcommander 的答案，使用generator function 真的很慢（该答案比没有.map(Number) 和console.log 的OP 慢约2.68 倍）

另外，我没有使用.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

上述函数运行速度极快。它比 OP（没有 .map(Number) 和 console.log）快约 3.13 倍，比 customcommander 的答案快约 8.4 倍。请记住，从 OP 中删除 console.log 会阻止它在每个减少步骤中产生一个数字。因此，这里需要将这些结果推送到数组中。

PT

Answer 6

这里有很多有趣的答案。我认为我的版本提供了另一个有趣的选择。

您使用所需的功能做几件事。您递归地将其减少到一位数。您记录中间值，并且您想要进行递归调用的计数。处理这一切的一种方法是编写一个纯函数，该函数将返回一个数据结构，其中包含最终结果、所采取的步骤和调用次数：

  {
    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])

Answer 7

你应该在你的函数定义中添加一个反参数：

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

Answer 8

由于您生成所有数字，另一种方法是使用生成器。

最后一个元素是您的编号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>

---

最后的想法

您可能需要考虑在您的函数中使用 return-early 条件。任何带有零的数字将返回零。

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

Answer 9

传统的解决方案是按照另一个答案的建议将计数作为参数传递给函数。

但是，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 变量的新实例。