Node 12中的代码错误，我想知道为什么？
function nloop(i, func) {
function recurse(obj, i, count) {
obj[count += 1] = func.call(null, count);
if (count === i) return obj;
return recurse(obj, i, count);
};
return recurse([], i - 1, -1);
};
var data = nloop(1000000, i => Math.round(Math.random(
浏览 0提问于2019-07-27得票数 0
回答已采纳
我正在解决上发布的问题。其中之一是编写一个函数来计算列表的长度。它应该是尾递归的。
天真的、非尾递归的解决方案是：
let rec length_naive xs = (** Not tail recursive *)
match xs with
| [] -> 0
| _ :: xs -> 1 + length_naive xs;;
(length_naive [@tailcall]) [1, 2, 3, 4];;
let one_hundred_million = 100000000;;
let non_tail_result = length_naive(L
浏览 13提问于2022-08-31得票数 2
回答已采纳
4回答
在这个站点和web的其他地方搜索，JVM不支持尾调用优化。因此，这是否意味着如果要在JVM上运行，就不应该编写尾部递归Scala代码，例如可以在非常大的输入列表上运行的以下代码？
// Get the nth element in a list
def nth[T](n : Int, list : List[T]) : T = list match {
case Nil => throw new IllegalArgumentException
case _ if n == 0 => throw new IllegalArgu
浏览 10提问于2011-04-17得票数 11
此代码生成它下面的堆栈跟踪：
import R from 'ramda';
function quicksort(list) {
if ( R.isEmpty(list) ) return list;
let pivot = R.head(list);
let lesser = R.filter( e => e < pivot , list );
let greater = R.filter( e => e >= pivot, list );
return R.concat( quicksort(lesser), pivot, q
浏览 2提问于2015-10-15得票数 0
回答已采纳
1回答
引用
...a尾调用是作为过程的最终动作执行的子例程调用。如果尾调用可能导致调用链后面再次调用相同的子例程，则该子例程被称为尾递归，这是递归的特例。
现在我已经用C编写了下面的例程
int foo (int x){
if ( x > 100)
return x-10;
else
return foo(foo(x+11));
}
基于上面的定义，在我看来foo应该是一个尾递归函数，因为它的递归调用是过程的最终操作，但在我曾经读过的某个地方，它不是尾递归函数。
因此，问题是：
为什么这个函数不是尾递归的？
浏览 6提问于2015-05-25得票数 1
2回答
在erlang中，尾递归比前向递归更好吗？
或者erlang编译器也优化了前向递归？
我的意思是，有没有理由使用尾递归而不是前向递归？
在我看来，前向递归看起来更漂亮。
浏览 2提问于2011-02-09得票数 6
回答已采纳
我在思考这里提出的问题之一()以及如何改进代码。
不管怎样，我是这样想的：
def simpledb_update(name: String, metadata: Map[String, String]) = {
def inner_update(attempt: int): Unit = {
try {
db(config("simpledb_db")) += (name, metadata)
return
} catch {
case e =>
if (attempt >= 6) {
浏览 1提问于2011-03-15得票数 1
回答已采纳
我见过一些使用while True循环让Python进行尾部调用优化的例子。例如。
def tail_exp(base, exponent, acc=1):
if exponent == 0:
return acc
return tail_exp(base, exponent - 1, acc * base)
变成了
def tail_exp_2(base, exponent, acc=1):
while True:
if exponent == 0:
return acc
exponent, ac
浏览 2提问于2020-09-08得票数 2
3回答
我目前正在阅读计算机程序(SICP)的结构和解释。在这本书的过程中，“您可以通过将递归过程写成尾递归来优化递归过程”的课程一遍又一遍地向读者灌输。事实上，我已经有将近100页了，而且还没有看到一个for或while循环--都是递归的。这开始让我担心了。据我所知，优化尾调用的方式可以有效地将尾递归过程转换为迭代过程，这在现代编程语言中并不常见。这给了我一个问题:如果我使用的是一种没有对尾递归进行优化的语言，我如何应用SICP教授的这些课程？知识是可以转让的吗？
浏览 0提问于2020-11-15得票数 2
回答已采纳
我理解递归函数的问题和堆栈溢出问题的风险。
然而，如果一个函数能够被优化为尾部递归，那么为什么这个优化不自动应用于ie。为什么我需要标记一个可以用@tailrec优化的函数？
浏览 1提问于2016-01-26得票数 4
回答已采纳
我只是在学习Ruby和一般的编程。作为我的第一个项目，我正在做一个21点的项目。我有一个方法start_game，它被调用来启动每一只新手。该方法被调用，然后在结束时再次调用自身。这是正确的方法吗？在我看来，每次调用该方法时，它都会无休止地分配内存。我不确定这是否是垃圾收集可以处理的东西。我觉得可能有一种更好的方法来做这件事，但我想不出来。提前感谢！
浏览 0提问于2012-04-17得票数 2
1回答
鉴于这一守则：
int x;
int a (int b) {
b = a (b);
b += x;
return b;
}
GCC为什么要返回这个输出(英特尔语法)： -哥德波特的GCC资源管理器
a:
sub rsp, 8
call a
mov edx, DWORD PTR x[rip]
add rsp, 8
lea eax, [rax+rdx*8]
add eax, edx
ret
并返回此输出(AT&T语法)： -Godbolt的Clang
a:
浏览 2提问于2014-06-29得票数 4
回答已采纳
1回答
我不知道我是做错了什么，还是它只是Scala编译器的一个属性--当我试图编译这段代码时，我得到了提到的编译错误：
@tailrec
def shiftDown2(x: Int, bound: Int) {
val childOfX = chooseChild(x, bound)
for (child <- childOfX) {
swap(x, child)
shiftDown2(child, bound)
}
}
而下面的代码编译时没有问题：
@tailrec
def shiftDown(x: Int, bound: Int) {
val childOf
浏览 3提问于2013-10-05得票数 2
回答已采纳
我需要使用JavaScript执行一些递归操作。
JavaScript引擎和Java一样工作吗？对于递归，Java在每次递归调用时都会启动一个新堆栈。JavaScript是如何处理这个问题的呢？
浏览 0提问于2013-06-18得票数 0
1回答
我们可以使用堆栈和递归以相反的顺序打印链表。我的老师说使用显式堆栈更好，因为递归也使用堆栈，但必须维护许多其他参数。即使我们使用stack中的std::stack，引用外部库不也很耗时吗？与使用递归解决方案相比，使用显式堆栈如何节省时间/空间？
浏览 34提问于2020-10-21得票数 0
回答已采纳
6回答
我知道递归function.....but的基本定义，我想知道它对内存的影响？？为什么没有选择它而不是循环或迭代？
浏览 1提问于2010-12-02得票数 1
回答已采纳
既然.net有操作码，这能用来判断一个F#函数是否真的是尾递归的吗？
如果这是真的，有没有人做了一个识别尾部和非尾部函数的VS插件？
浏览 0提问于2012-03-14得票数 4
回答已采纳
如果运行以下代码：
public static void main(String[] argsv) {
long whichFib = 45;
long st;
st = System.currentTimeMillis();
System.out.println(recursiveFib(whichFib));
System.out.println("Recursive version took " + (System.currentTimeMillis() - st) + " milliseconds.");
浏览 4提问于2013-01-12得票数 2
回答已采纳
2回答
我使用尾部递归编写了以下随机化快速排序代码。我想看看不使用尾递归的效果，并想看看执行时间和运行时间是如何影响的。我们如何从下面的随机快速排序代码中删除尾部递归？
#include<iostream>
#include<cstdlib>
using namespace std;
int partition(int low,int high,int a[])
{
int index=(rand()%(high-low))+low;
//cout<<endl<<index<<"----"<<en
浏览 0提问于2016-04-07得票数 1
2回答
在不同的地方，我看到了使用堆栈实现快速排序比使用递归更快的说法。这是真的吗？我知道编译器通常擅长将递归转换为迭代，但是链接到页面上的注释要求它过于复杂，无法进行优化。
对于快速排序还有哪些其他优化？
下面是一些我认为单独实现比递归实现更好的地方：
尽管如此，函数仍然是递归的，使用函数调用堆栈存储中间值l和h，函数调用堆栈存储其他簿记信息和参数。此外，函数调用涉及开销，例如存储调用方函数的激活记录，然后继续执行。
在辅助堆栈的帮助下，可以轻松地将上述函数转换为迭代版本。
我了解到递归算法总是比迭代算法慢。
然而，答案指出，这并不总是正确的，尽管我不明白为什么会为在系统堆栈上存储函数状
浏览 2提问于2014-07-15得票数 1
2回答
如果bar调用bar(i/2)，如果我是偶数，而bar(3*i + 1)，则递归函数条将尾递归。
const int bar(const int i)
{
if (i < 2) return i;
return i % 2 ? bar(i/2) : bar(3*i + 1);
}
但是，如果bar调用bar或foo，谁的局部变量集合与bar完全不同呢？
const int bar(const int i)
{
if (i < 2) return i;
return i % 2 ? bar(i/2) : foo(3*i + 1);
// where foo i
浏览 0提问于2018-03-21得票数 1
回答已采纳
我编写了三个版本的fibonacci序列，我不太确定它们的时间/空间复杂性(以及为什么)：
变体1:头递归
int fibonacci_h(int n) {
if (n == 1 || n == 2) {
return 1;
}
return fibonacci_h(n - 1) + fibonacci_h(n - 2);
}
变体2:尾递归
int fibonacci_t(int n, int s_last = 0, int last = 1) {
if (n == 1) {
return last;
}
return fibonacci_t(n -
浏览 0提问于2020-10-23得票数 1
2回答
使用尾递归实现Tak函数
、、、
是否有可能实现
尾部递归在C/C++中的一种方式，以便使gcc/g++可以执行尾部递归优化？
我不确定嵌套的递归函数调用是否会使编译器感到困惑。
浏览 0提问于2013-11-14得票数 0
4回答
哪一个是尾递归？
、、、
我看到以下这两个函数在语法上都是尾递归函数，但是，在racket中，哪一个函数实际上被视为尾递归，还是两者兼而有之？我的意思是它是否是由解释器作为尾递归优化的。
;;1
(define (foo i m s)
(if (< i m)
(foo (+ i 1) m (+ i s))
s))
;;2
(define (foo i m s)
(if (= i m)
s
(foo (+ i 1) m (+ i s))))
在其他的lisps中是否有不同的答案？
浏览 9提问于2013-03-17得票数 2
回答已采纳
6回答
据我所知，由于函数调用的开销，递归函数通常比等效的非递归函数效率低。然而，我最近遇到了一本教科书，书中说这对Java (和C#)来说不是必须的。
它没有说明原因，但我认为这可能是因为Java编译器以某种方式优化了递归函数。
有没有人知道为什么会这样？
浏览 1提问于2011-03-11得票数 6
回答已采纳
3回答
这是一个展示尾递归的好例子吗？
public printName(){
System.out.println("Smith");
printName();
}
我不打算在现实生活中这样做，但我把这个作为我考试的一个例子。这个是正确的吗？
浏览 0提问于2012-07-21得票数 4
1回答
我注意到新版本的JSLint不喜欢某些形式的for循环。我发现这很奇怪，于是开始寻找一些解释。在JsLint的中，您可以找到以下内容：
ES6最重要的新特性是正确的尾调用。这没有新的语法，所以jsLint没有看到它。但是它使递归更有吸引力，这使得循环，特别是循环，变得更加吸引人。
这是：
jsLint不建议使用for语句。而是使用像forEach这样的数组方法。for选项将禁止某些警告。jsLint接受的forms格式受到限制，不包括新的ES6表单。
这两条语句给我留下了一个混乱的字节。我一直觉得for循环是最好的循环方式，主要是因为：
有些迭代方法还没有得到很好的支持。
浏览 1提问于2015-05-21得票数 8
回答已采纳
2回答
我写了一个函数来计算整数的幂，然后取模数。我想知道我做的是不是尾部递归：
int takeModulusTAILRECURSION(int coef, int x, int n, int module){
int result = 0;
if ( n > 0 )
result = takeModulusTAILRECURSION( mod(coef * x, module), x , n - 1, module );
else if ( n == 0)
result = mod ( coef
浏览 1提问于2011-02-19得票数 1
回答已采纳
我最近一直在读关于Erlang的文章，以及由于使用迭代循环的困难，尾递归是如何被大量使用的。
递归的频繁使用不会减慢它的速度吗?所有的函数调用和它们对堆栈的影响会怎样呢？或者，尾递归会否定大部分吗？
浏览 0提问于2009-07-09得票数 8
回答已采纳
2回答
在Scala中的函数式编程一书中，在解释递归是如何在命令式迭代的函数式编程中经常使用的上下文中，作者使用名为"go“或"loop”的助手函数通过阶乘函数显示递归，并声明这是Functional编程的标准实践：
...
def factorial(n: Int): Int = {
@tailrec def go(n: Int, acc: Int): Int = {
if (n <= 0 ) acc
else go(n - 1, n*acc)
}
go(n, 1)
}
因此，如果不是更简洁地定义它，如果没有助手函数，...but也同样容易：
...
浏览 4提问于2020-09-16得票数 4
回答已采纳
1回答
我遵循着雄辩的Javascript书，并做了链接列表练习。我被递归困住了。我使用以下代码：
function arrayToList(array){
var list = {};
length = array.length;
while(array.length > 0){
element = array.pop();
if (length == array.length + 1 )
list = { value: element, rest: null};
else
浏览 3提问于2015-06-09得票数 0
回答已采纳
我意识到无序遍历的代码看起来像
if left[x] != NULL
recurse left
process
right[x] !=NULL
recurse right
我把一切都编好了，运作得很好。然后我开始更多地思考，并对这个过程进行了仔细的思考，现在我迷失了递归的实际工作方式。因为我认为一直到左边，递归就会结束，因为两个节点都是空的。
如果我一直都是左，并且左右节点都是空的，那么递归调用如何使我回到父节点继续遍历呢？
浏览 2提问于2015-03-12得票数 1
回答已采纳
2回答
我想知道这样的东西是否可以在代码中使用。如果我想要执行的代码块在程序的许多部分都是相同的，并且它使用了这个版本的while循环，那么它能工作吗？(我知道我可以使用while循环，我只是觉得这是一个值得探索的有趣想法)
NSMutableArray *objects;
-(void) RemoveObjectLoop
{
[self RemoveObjectAtZero];
}
-(void) RemoveObjectAtZero
{
if([objects count] > 0)
{
[objects removeObjectAtIndex:0]
浏览 1提问于2011-12-03得票数 0
回答已采纳
2回答
在Scala2.8.x中，添加了一个新的注释(@tailrec)，如果编译器不能对带注释的方法执行尾调用优化，则会产生编译时错误。
在loop/recur方面，是否有类似的工具
编辑:在阅读了我的问题的第一个答案(谢谢，Bozhidar )并在Clojure文档中进一步搜索之后，我看到了以下内容：
(重述exprs*)
按顺序计算exprs，然后并行地将递归点的绑定重新绑定到exprs的值。如果递归点是fn方法，则重新绑定params。如果递归点是循环，则重新绑定循环绑定。执行然后跳回递归点。重新出现的表达式必须与递归点的一致性完全匹配。特别是，如果递归点是变量fn方法的顶部，则不需要收集re
浏览 2提问于2010-04-26得票数 9
回答已采纳
3回答
我见过很多在二进位排序树中搜索的搜索算法，但它们都使用了相同的方法:递归。我知道与循环相比递归花费很大，因为每次我们调用搜索函数时，都会为该方法创建一个新的堆栈框架，如果二叉树太大，最终会占用大量内存。
为什么我们不能像这样搜索二进制搜索树：
while (root!=NULL)
{
if (root->data==data)
return 0;
else if (data > root->data)
root=root->right;
else
root=root->left;
}
我认为这
浏览 5提问于2014-08-09得票数 0
回答已采纳
2回答
我读过一篇文章，声称foldl可能很容易发生堆栈溢出。发布示例代码为：
maximum [1..1000000]
代码不会在我的机器上溢出。但是，它可能会因环境而异。我像这样增加了数字：
maximum [1..1000000000]
它导致了硬盘交换，所以我不得不停止评估。示例代码并不重要。堆栈溢出真的发生了吗？或者仅仅是一个过去的故事？
浏览 1提问于2011-02-12得票数 4
回答已采纳
2回答
def singlesR(xs):
if xs != [] :
return [[xs[0]]] + singlesR(xs[1:])
else :
return []
如何转换为尾递归函数？
#result value
singlesR([1,2,3,4]) == [[1], [2], [3], [4]]
浏览 4提问于2022-03-21得票数 1
回答已采纳
3回答
我在下面的F#定义中看到了一个连续传递风格的斐波纳契函数，我一直认为它是尾递归的：
let fib k =
let rec fib' k cont =
match k with
| 0 | 1 -> cont 1
| k -> fib' (k-1) (fun a -> fib' (k-2) (fun b -> cont (a+b)))
fib' k id
在Scala中尝试等效代码时，我使用了现有的@ tail are，当Scala编译器通知我递归调用不处于尾位置时，我感到措手不及：
def fib(k
浏览 5提问于2015-06-23得票数 3
回答已采纳
2回答
我喜欢在任何时候使用递归，这似乎是一种比实际循环更自然的循环方式。我想知道lisp中的递归是否有任何限制？就像在python中，它会在1000次循环后崩溃吗？你可以用它来做游戏循环吗？
现在测试它，简单的计数递归函数。现在是>7000000！
非常感谢
浏览 1提问于2010-06-08得票数 13
回答已采纳
5回答
据我所知，递归在OOP和过程化编程中非常优雅，但效率低下(参见精彩的"High Order perl"，Mark Jason Dominus)。我有一些信息，在函数式编程中，递归保持了它的优雅和简单性。有人能证实并可能放大这一点吗？我正在考虑XSLT和Haskell (在我的下一种学习语言列表中名列前茅)
谢谢
丹尼尔
浏览 33提问于2010-02-26得票数 18
回答已采纳
6回答
我一直在阅读文章，描述如何通过使用尾递归版本来降低快速排序的空间复杂性，但我无法理解这种情况是如何发生的。以下是两个版本：
QUICKSORT(A, p, r)
q = PARTITION(A, p, r)
QUICKSORT(A, p, q-1)
QUICKSORT(A, q+1, r)
TAIL-RECURSIVE-QUICKSORT(A, p, r)
while p < r
q = PARTITION(A, p, r)
TAIL-RECURSIVE-QUICKSORT(A, p, q-1)
p
浏览 14提问于2013-11-08得票数 20
回答已采纳
5回答
在Python中，有一个最大的递归深度。这似乎是因为Python是解释而不是编译的。C++也有同样的概念吗？或者它只与内存限制连接？
浏览 13提问于2010-04-13得票数 65
回答已采纳
6回答
我试图用c++编写一个简单的递归求和函数：
long long int recursum(long long int n){
if(n==1)
return 1;
else
return recursum(n-1)+n;
}
这应该是可行的，但是我得到了值大于25000的分段错误。我非常确定这应该能工作，因为这是一个非常简单的递归，带有一个终结语句。
浏览 5提问于2013-12-08得票数 1
回答已采纳
1回答
了解如何将递归转换为蹦床
、、、
我最近读到过关于蹦床是一种消除尾部呼叫的方法。我想把我的一个功能转换成使用蹦床的东西，但是我很难开始工作(我是从OO世界来的)。
def buildTree (X:DenseMatrix[Double], Y:DenseVector[Double], minBucket:Int):Node = {
// Get the split variable, split point and data for this data
val (splitVar, splitPoint, leftX, leftY, rightX, rightY) = chooseSplit(X
浏览 5提问于2014-04-01得票数 0
回答已采纳
4回答
如果我没记错的话，尾递归函数总是有一个简单的非递归等价函数。由于递归涉及不必要的函数调用开销，因此最好使用非递归方式。
这个假设总是正确的吗？还有没有其他支持/反对尾递归的论点？
浏览 2提问于2010-07-20得票数 4
回答已采纳
3回答
我正在研究一些实际的JavaScript问题，并解决了一个涉及递归的问题。虽然我做得对，但我的实现与“官方”解决方案不同，所以我想知道是否有人对官方答案是否更好有任何见解，如果是的话，原因何在。
问题
实现一个函数，该函数以一个函数作为其第一个参数，一个数字num作为其第二个参数，然后执行传递的函数num时间。
在您的实现中使用循环是可以的，如果您使用递归，则可以加分。
我的解决方案
function repeat(operation, num) {
if (num > 0) {
operation();
repeat(operation
浏览 2提问于2015-11-28得票数 8
回答已采纳
3回答
我最近读到了几个被声明为static的递归函数。
在函数声明前添加static对优化尾递归函数有帮助吗？这是获得优化所必需的吗？
浏览 1提问于2012-10-29得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
