看帖子有人说可以用FTP上传模式来使用COS，刚刚好Discuz 是有FTP上传功能，但是我们怎么使用呢怎么获取FTP信息呢？有没有详细的设置方法，目前在没有Discuz 插件的情况下也只能用FTP功能了，苦于现在没有出这样的教材
浏览 611提问于2016-03-25
1回答
我开始学习Lisp，使用SICP的书。作者提到，过程(即函数)可以是递归的，也可以是迭代的。此外，这些过程生成的过程也将是递归的或迭代的，令人惊讶的是，递归过程有时可以生成迭代过程。
给出的例子是阶乘过程，它是一个递归过程，但它生成一个迭代过程：
(define factorial n)
(iter 1 1 n))
(define (iter product counter max-count)
(if (> counter max-count)
product
(iter (* counter product)
浏览 0提问于2014-02-03得票数 3
回答已采纳
1回答
我已经编写了以下函数来查找给定列表"lst“中的给定项目"x”，如果找到，则返回其索引，否则将返回错误：
exception Failure of string
let rec func x lst c = match lst with
| [] -> raise(Failure "Not Found")
| hd::tl -> if (hd=x) then c else func x tl (c+1)
let find x lst = func x lst 0
这个函数是完全工作的，我想知道它的内存消耗是多少？这意味着内存消耗
浏览 4提问于2015-07-08得票数 6
回答已采纳
2回答
在Scala2.8.x中，添加了一个新的注释(@tailrec)，如果编译器不能对带注释的方法执行尾调用优化，则会产生编译时错误。
在loop/recur方面，是否有类似的工具
编辑:在阅读了我的问题的第一个答案(谢谢，Bozhidar )并在Clojure文档中进一步搜索之后，我看到了以下内容：
(重述exprs*)
按顺序计算exprs，然后并行地将递归点的绑定重新绑定到exprs的值。如果递归点是fn方法，则重新绑定params。如果递归点是循环，则重新绑定循环绑定。执行然后跳回递归点。重新出现的表达式必须与递归点的一致性完全匹配。特别是，如果递归点是变量fn方法的顶部，则不需要收集re
浏览 2提问于2010-04-26得票数 9
回答已采纳
4回答
我认为在函数式编程语言中非常有用。那C呢？
C语言或编译器是否支持尾调用消除
程序是否为新调用创建新的堆栈框架？
来自wiki：
可以在不向调用堆栈添加新堆栈帧的情况下实现尾调用。当前过程的大部分框架不再需要，它可以被尾调用的框架所取代，并根据需要进行修改(类似于对进程的覆盖，但对于函数调用)。
然后，程序可以跳到被调用的子例程。产生这样的代码而不是标准的调用序列称为尾呼叫消除。
浏览 5提问于2016-02-02得票数 0
回答已采纳
2回答
我正在寻找gsub的一个版本，它不尝试将其输入解释为正则表达式，并且使用类似于C的普通转义字符串。
更新
这个问题是由一种奇怪的行为引起的：
text.gsub("pattern", "\\\\\\")
和
text.gsub("pattern", "\\\\\\\\")
被视为相同的，以及
text.gsub("pattern", "\\\\")
被视为单个反斜杠。
浏览 2提问于2013-03-28得票数 0
回答已采纳
1回答
递归问题
、、、
void function(int x){
if(x<=0)
return;
function(x--);
}
这是一个递归函数，其值为x= 20。
递归电话将以这种方式进行
function(20)...function(19).......function(0)
每个函数调用都将使用一些内存，如果数据很大，它将抛出StackOverflowException。
所以我想知道的是：
是否有任何方法可以调用一个函数并将其从调用堆栈中移除，以便它的内存可以被利用(例如。函数(20)调用函数(19)之后，函数(20)的内存应该被取消分配)，递归调用的结束(此
浏览 0提问于2016-01-15得票数 -2
回答已采纳
1回答
我的理解(这可能是不正确的或不完整的)是，懒惰的评估可以提供尾巴递归的所有优点，并且做得更好。
如果是这样的话，这是否意味着在惰性评估的上下文中不需要尾递归？
更新
具体来说，让我们看看下面的示例：
(define (foo f a)
(if (number? a)
(* a a)
(lazy-map foo a)))
这个函数可以很容易地转换成尾递归函数.然而，如果是这样的话，我们将失去懒惰的优势-评估。
实际上，当输入是相当大的列表(或无限)时，这个非尾递归函数需要消耗许多堆栈吗？我不这样认为。那么，是否有充分的理由使用tail-recursion而不是惰性评估？
浏览 3提问于2016-01-08得票数 3
RealWorldHaskell第8章
globToRegex' (c:cs) = escape c ++ globToRegex' cs
这个函数不是尾递归的，它说答案依赖于Haskell非严格(懒惰)的评估策略。(++)操作符的简单定义如下所示，它不是尾递归的。
( ++ ) :：a -> a -> ++ ys =x：(xs ++ ys) [] ++ ys = ys
在一种严格的语言中，如果我们计算"foo" ++ "bar"，整个列表将被构造，然后返回。非严格的评估推迟了大部分工作，直到需要为止。
如果我们要求表达式"
浏览 6提问于2011-06-03得票数 6
3回答
是否有一个属性可以告诉编译器，即使没有设置全局/o+编译器开关，也必须始终对方法进行优化？
我之所以问这个问题，是因为我在玩弄基于现有方法的IL代码动态创建方法的想法；当对代码进行优化时，我想要做的操作相当简单，但在非优化代码中变得非常困难，因为编译器生成了额外的指令。
编辑:关于困扰我的非优化的更多细节.
让我们考虑阶乘函数的以下实现：
static long FactorialRec(int n, long acc)
{
if (n == 0)
return acc;
return FactorialRec(n - 1, acc * n);
}
(注:我知
浏览 3提问于2012-03-13得票数 16
回答已采纳
2回答
我最近在学习日期结构。在Mark的书“C中的数据结构和算法分析”中，为什么他说尾递归是递归的糟糕用法，最好不要在第三章中使用它？但我看到很多人说它在网上很有用。
浏览 0提问于2013-09-10得票数 4
回答已采纳
嗨，我是二郎世界的新手。当我想到我们需要如何解决以下问题时(并且有一长串类似的问题)，我认为这是非常低效率的，因为我们谈论的是大量的递归。很明显，像C/Java这样的语言不需要笨拙的递归来解决这个问题，但是使用Erlang (我想其他函数编程语言也需要，也许？)你必须这样做。
示例3-附加
该程序连接两个列表：
append([], List) -> List;
append([First|Rest], List) -> [First | append(Rest,List)].
有人能解释一下为什么这不是问题吗？
浏览 8提问于2009-09-30得票数 4
3回答
我目前正在阅读计算机程序(SICP)的结构和解释。在这本书的过程中，“您可以通过将递归过程写成尾递归来优化递归过程”的课程一遍又一遍地向读者灌输。事实上，我已经有将近100页了，而且还没有看到一个for或while循环--都是递归的。这开始让我担心了。据我所知，优化尾调用的方式可以有效地将尾递归过程转换为迭代过程，这在现代编程语言中并不常见。这给了我一个问题:如果我使用的是一种没有对尾递归进行优化的语言，我如何应用SICP教授的这些课程？知识是可以转让的吗？
浏览 0提问于2020-11-15得票数 2
回答已采纳
3回答
我用Racket编写了一个小型编译器，用于类似于方案的语言。现在，我想为我的编译器实现TCO。
我的想法是:在将尾部调用转换为中间媒体表示之前，我需要检测它们。但是从这个看来，TCO通常是通过将call更改为jmp来完成的。我被困在这里了。
如有任何建议，将不胜感激。
编辑：我的目标是x86程序集代码。我使用的IR是三个地址码。
下面是我的编译器的12张代码，平坦的pass是我将源代码转换成IR的地方
(define test-passes
(list
`("uniquify" ,(uniquify '())
浏览 6提问于2016-09-30得票数 3
1回答
在阅读时，我在Haskell中编写了这个几乎是尾部递归的示例：
triangle :: Int -> Int
triangle 0 = 0
triangle x = x + triangle (x - 1)
这当然不是一个尾调用，因为尽管递归调用在“返回”本身中，但是x +防止当前堆栈被重用到递归调用中。
但是，可以将其转换为尾递归代码(尽管非常丑陋和冗长)：
triangle' :: Int -> Int
triangle' = innerTriangle 0
where innerTriangle acc 0 = acc
innerT
浏览 4提问于2016-03-09得票数 3
回答已采纳
2回答
我刚刚开始学习Haskell，并将阅读书籍和教程与解决Euler项目中的问题结合起来。由于使用以下代码获得"C堆栈溢出“错误，所以我一直停留在上：
euler.hs
divisors n = [x | x <- [1..n `div` 2], n `mod` x == 0] ++ [n]
is_prime n = divisors n == [1, n]
f a b = [n^2 + a * n + b | n <- [0..]]
primes_from_zero a b = length(takeWhile is_prime (f a b))
命令窗口
这个命令给出欧拉系
浏览 4提问于2008-12-16得票数 4
回答已采纳
3回答
我知道尾递归是函数对自身进行尾部调用的一种特殊情况。但是我不明白尾部调用和尾部递归有什么不同。在具有实现TCO (尾部调用优化)的“正确尾部递归”语言中，如Scheme，这意味着尾部调用和尾部递归不会消耗堆栈或其他资源。在编译器不能优化尾递归语言中，程序可能会在堆栈之外运行并崩溃。在“正确的尾递归”语言中，我认为实现循环的尾递归并不比使用循环的效率低。
浏览 0提问于2012-08-21得票数 19
1回答
大输入的堆栈溢出
、、、、
所以这是我程序的一部分。当我为相差超过250000的数字调用bound时，它会导致堆栈溢出。我该如何解决这个问题呢？对于较小的输入，该程序运行良好。我很确定程序的其余部分都很好。有没有办法重写函数，让它们正常工作？我不喜欢使用for while循环。谢谢
let rec sqdigits a =
if a = 0 then 0
else ( a mod 10)*( a mod 10) + sqdigits (a/10);;
let rec bound c d =
if c>d then []
else (sqdigits (c))::(bound (c+1) d);;
浏览 0提问于2015-05-15得票数 0
1回答
这不是尾递归吗？(堆栈溢出错误)
、、、、
这是我写的一个小函数，用来检查一个整数是否为质数：
int prime(int x, int y = 2)
{
if(y <= x/2)
{
if((x % y) == 0)
return 0;
}
else
return 1;
return prime(x, ++y);
}
现在，我用visual Studio2012编译它，如果我给它一个很大的值，比如105943，就会发生堆栈溢出错误，代码会中断。现在，这个函数不是尾递归的吗？如果是这样，那么不应该为递归调用维护堆栈，并且不应该发生溢出
浏览 2提问于2013-06-20得票数 2
回答已采纳
我已经写了一个简单的猜测数字的程序，我需要知道其中是否涉及到任何类型的递归，以及它是哪种类型(原语/尾部)(我对此是新手，所以请容忍我)
module MyProgram where
import System.Random
guessNum :: IO()
guessNum =
do --gen <- newStdGen
--let num = randoms gen :: [Int]
num<-randomRIO(20,100 :: Int)
putStrLn "Guess the number: "
input<-ge
浏览 0提问于2012-02-04得票数 3
回答已采纳
我有以下节目：
my_sum 0 = 54321
my_sum i = i + (my_sum (i - 1))
main = do
print $ my_sum 12345
我想知道生成的my_sum函数是否是递归的。换句话说，将haskell转换为非递归类型。
我试图看到本地的c-代码(asm几乎一样)。但对我来说太难了。这是my_sum的代码
my_sum_s24N_entry() // [R1]
{ info_tbl: [(c25x,
label: block_c25x_info
rep:
浏览 1提问于2017-01-09得票数 0
回答已采纳
我想做一个BigInteger的阶乘(在Kotlin中)。使用尾递归，当我尝试执行9000时，就会得到StackOverFlow错误！用一个非递归函数我可以做到.但我很好奇如何避免这种错误。
这是我的代码：
import java.math.BigInteger
fun tail_recursion_factorial(n: BigInteger, factorialOfN: BigInteger = BigInteger.valueOf(2)): BigInteger {
return when(n){
BigInteger.ONE -> BigInteger
浏览 2提问于2017-09-04得票数 1
回答已采纳
1回答
我使用两个按钮，必须根据iPhone设备如iPhone4，5和6给出可变的宽度，使用约束，前导，尾随和两个按钮之间的间距应该相同。
浏览 2提问于2015-07-05得票数 1
2回答
为什么Clojure有“重新出现”的特殊形式？
当我将"recur“替换为函数本身时，我得到了相同的结果：
(defn print-down-from [x]
(when (pos? x)
(println x)
(recur (dec x))
)
)
(print-down-from 5)
其结果与
(defn print-down-from [x]
(when (pos? x)
(println x)
(print-down-from (dec x))
)
)
(print-down-from 5)
我想知道“重新出现
浏览 3提问于2015-12-04得票数 11
回答已采纳
1回答
我认为我理解尾递归函数的教科书定义:函数调用后不执行任何计算的函数。因此，尾递归函数的内存效率将更高，因为每次调用只需要一个记录，而不需要每个记录(就像正常递归中的那样)。
我不太清楚的是这个定义是如何应用于嵌套调用的。我将提供一个例子：
func foo91(x int)
if(x > 100):
return x - 10
else:
return foo91(foo91(x+11))
我最初想出的答案是，根据定义，它不是尾递归(因为外部调用是在计算内部调用之后执行的，因此其他计算是在第一个调用之后执行的)，所以通常使用嵌套递归调用的函
浏览 4提问于2020-01-16得票数 0
回答已采纳
我有这样的测试代码：
public class Constants {
public static String c1 = "C1";
static {
System.out.println("Constants Class Loaded!");
}
}
public class Test {
public static void main(String[] args) {
String c1 = Constants.c1;
System.out.println(c1);
}
}
其产出是：
Const
浏览 1提问于2014-03-26得票数 3
回答已采纳
列举了F#性能有时优于C#的一些原因，在它的“第一”部分中说，只有F#才能生成尾调用。
那到底是什么意思？为什么这是一种性能提升？对于我使用大量递归的象棋应用程序来说，这一件事实际上可能会在F#和C#之间产生或破坏。
浏览 1提问于2015-08-27得票数 3
回答已采纳
在实现尾部调用优化的语言中，递归深度的理论/实践限制是什么？(请假设递归函数是正确的尾部调用)。
我的猜测是，理论上的限制是无，因为没有递归过程，即使它是递归过程。实际限制是可用的主内存允许使用的限制。如果我说错了，请澄清或改正。
浏览 1提问于2009-05-15得票数 0
回答已采纳
1回答
我正在尝试编写一个Scheme解释器，但发现TCO很难实现。我不知道函数必须具备哪些属性才能启动TCO。
1)定义末尾具有自递归调用的函数：
(define (sum-list list accum)
(if (null list) accum
(sum-list (cdr list) (+ accum 1))))
2)具有自递归调用的函数，该函数不位于定义的末尾：
(define (sum-list list accum)
(cond ((not (null list))
(sum-list (cdr list) (+ accum 1)))
浏览 5提问于2013-09-15得票数 6
回答已采纳
5回答
在Python中，有一个最大的递归深度。这似乎是因为Python是解释而不是编译的。C++也有同样的概念吗？或者它只与内存限制连接？
浏览 13提问于2010-04-13得票数 65
回答已采纳
是否某些语言或平台没有固定的堆栈大小，因此不容易溢出？我记得在UNIX上使用C时，堆栈很难溢出，而在Win3.1的日子里，堆栈很容易溢出。
浏览 0提问于2009-05-29得票数 1
回答已采纳
5回答
我开始学习ocaml，并且真正体会到了递归在语言中的威力。然而，我担心的一件事是堆栈溢出。
如果ocaml使用堆栈进行函数调用，它最终不会溢出堆栈吗？例如，如果我有以下函数：
let rec sum x =
if x > 1 then f(x - 1) + x
else x;;
它最终一定会导致堆栈溢出。如果我在c++中做同样的事情(使用递归)，我知道它会溢出。
所以我的问题是，有没有内置的保护措施来防止函数式语言溢出堆栈？如果不是，它们是不是像这样不太有用，因为上面的求和算法是用for循环的过程化风格编写的，可以处理任何数字(与整数溢出无关)？
浏览 4提问于2009-08-18得票数 5
回答已采纳
1回答
这是我们教授写的一篇教程，我无法理解它。我可以想出派生词，但我不能仅仅通过分析推导就想出语法。
在这方面，“匹配”指的是什么？
你能解释一下matched_if，matched_stmt，unmatched_if是如何用简单的单词工作的吗？
The following is an unambiguous grammar for the problem:
stmt → if_stmt | nonif_stmt
if_stmt → matched_if | unmatched_if
matched_if → 'if' logical_expr 'then' mat
浏览 6提问于2014-12-31得票数 0
回答已采纳
1回答
尾递归:比较两种情况
、、、
为什么这是尾部递归：
def navigate(myList : List[Int]) : (Int, List[Int]) = {
def navigate(step: Int, offset: Int, myList: List[Int]): (Int, scala.List[Int]) = {
if //some test and exit condition, then a definition of jump
else navigate(step + 1, offset + jump, myList)
}
navigate(0, 0
浏览 1提问于2017-12-06得票数 1
在C中，你可以像这样定义常量
#define NUMBER 9
这样，无论程序中数字出现在哪里，它都会被替换为9。但是Visual C#不会这样做。它是如何做到的？
浏览 2提问于2009-11-27得票数 38
回答已采纳
1回答
方案中的递归和调用堆栈
、、、、
我是一名大学生，学习球拍/计划和C作为我的CS学位的入门课程。
我在网上读到，与C中的递归相比，使用迭代通常是最好的做法，因为递归由于将堆栈帧保存到回调堆栈上而代价高昂，等等.
现在，在函数语言(如Scheme )中，递归一直被使用。我知道尾递归在Scheme中是一个巨大的好处，据我所知，它只需要一个堆栈框架(有人能澄清这一点吗？)不管递归有多深。
我的问题是:无尾递归怎么样？每个函数应用程序是否保存在调用堆栈上？如果我能简单地了解一下它是如何工作的，或者向我指出一个资源，我将非常感激；我似乎找不到一个明确说明这一点的地方。
浏览 3提问于2014-01-24得票数 3
回答已采纳
在下面的代码中，为什么Pi被分成三个常量P1、P2和P3？有相关的数学理论吗？如果是为了提高r的计算精度，我将以更高的精度运行该代码，但没有任何改进。(来自gsl/specfunc/trig.c:576)
const double P1 = 4 * 7.85398125648498535156e-01;
const double P2 = 4 * 3.77489470793079817668e-08;
const double P3 = 4 * 2.69515142907905952645e-15;
const double TwoPi = 2*(P1 + P2 + P3);
浏览 6提问于2016-09-24得票数 3
回答已采纳
4回答
如何编写一个从1到n计数的函数countTo(n)，并在不使用显式循环(仅递归)的情况下打印每个数字？
该解在空间和时间上必须是渐近最优的，即使没有尾部呼叫优化，给定任意大的n。
注意:最优时间复杂度是O(1)，而最优空间复杂度是O(log )--即使在迭代情况下也是如此，因为需要打印(任意大的)数字。
这个问题来自，相关的细节来自于讨论(否则问题就无法回答，因为他们最初的陈述是错误的假设)。
浏览 6提问于2012-02-12得票数 0
回答已采纳
2回答
函数编程中有这样的CPS技巧，即采用非尾递归函数，并以连续传递方式(CPS)重写它，从而使其成为尾递归函数。很多问题都涉及到这个问题，比如
举个例子
let rec count n =
if n = 0
then 0
else 1 + count (n - 1)
let rec countCPS n cont =
if n = 0
then cont 0
else countCPS (n - 1) (fun ret -> cont (ret + 1))
第一个版本的count将在每个递归调用中累
浏览 6提问于2016-02-01得票数 7
回答已采纳
2回答
我在读。其中一个提到：
让编译器生成尾递归代码似乎是一个简单的想法。但是大多数用于通用语言的编译器，包括C和Pascal，都不这样做，因此这些语言不能仅用过程调用来表示迭代过程。在这些语言中，尾递归的困难在于它们的实现使用堆栈来存储过程参数和局部变量以及返回地址。
如果堆栈用于过程参数、局部变量和返回地址，我无法理解为什么不能实现尾递归。
浏览 2提问于2014-12-22得票数 4
回答已采纳
3回答
最近，我试着和GCC一起编写类似这样的程序：
int f(int i){
if(i<0){ return 0;}
return f(i-1);
f(100000);
它运行得很好。当我检查堆栈帧时，编译器将程序优化为只使用一个帧，只需跳回到函数的开头，只替换f的参数。而且-编译器甚至没有在优化模式下运行。
现在，当我在Python中尝试同样的事情时，我遇到了最大的递归墙(或者如果我将递归深度设置得太高，可能会导致堆栈溢出)。
有没有办法让像python这样的动态语言利用这些优化呢？也许可以使用编译器而不是解释器来实现这一点？
只是好奇而已！
浏览 1提问于2010-03-24得票数 8
回答已采纳
4回答
哈斯克尔的foldR尾部递归吗？
、、、、
我对Haskell很陌生，我读过Haskell的第一原则，在第384页中，我遇到了FoldR，它似乎不是尾部递归的
foldr :: (a -> b -> b) -> b -> [a] -> b
foldr f z [] = z
foldr f z (x:xs) = f x (foldr f z xs)
1-我们能使它的尾递归吗？
2-它会被优化吗？
浏览 3提问于2021-04-27得票数 4
2回答
因此，技术上的 .NET确实支持尾调用优化(TCO)，因为它有它的操作码，而只有C#不生成它。
我不太清楚为什么TCO需要一个操作码或者它会做什么。据我所知，能够执行TCO的要求是，递归调用的结果不与当前函数作用域中的任何变量相结合。如果你没有，那么我看不出操作码是如何阻止你保持堆栈帧打开的。如果有，那么编译器就不能总是轻松地将其编译成迭代的东西吗？
那么，操作码有什么意义呢？很明显我错过了什么。在TCO完全有可能的情况下，难道不能总是在编译器级别而不是在操作代码级别进行处理吗？什么是它不能做到的例子？
浏览 2提问于2014-11-20得票数 13
回答已采纳
1回答
根据的说法，Ruby是一个“使用本机架构的双精度浮点表示的不精确实数”。
这是否意味着在32位Ruby上，它们等同于C float，在64位Ruby上等效于C double
如果是，我如何在运行时找到程序运行在哪个Ruby上(准确地说，是多少位)？它应该适用于任何操作系统和任何ruby实现(mri、rubinius和jruby)。
我想出的解决办法是：
def architecture_bits
1.size * 8
end
这在任何情况下都有效吗？有没有更好/更优雅的方法？
浏览 5提问于2014-11-08得票数 0
回答已采纳
5回答
由于性能的影响，我非常困惑，使用Const或resx的最佳方法是什么？这两种方法都是在C#中编译时使用的。我问的是普通问题，而不是依赖于语言的问题。
有谁能深入解释一下吗？
浏览 0提问于2013-12-17得票数 2
1回答
GCC在试图编译时给我以下警告信息：
las.c:13:18: warning: initializer element is not a constant expression [enabled by default]
const int ROWS = pow (2, MESH_K);
与此相关的代码部分是：
#define MESH_K 10
#define BUFF_SIZE 30
const int ROWS = pow (2, MESH_K);
我需要在代码的后面点同时使用MESH_K和行。我知道函数调用可能导致GCC相信这不是一个固定的表达方式。但是，考虑到对pow的调用
浏览 4提问于2013-11-23得票数 3
回答已采纳
对于c和c++相同的程序，当我们使用常量整数变量作为case标签时，它只在c++中有效，而在c中不有效，当我们使用常量整数数组成员作为case标签时，它对c和c++都无效。这种行为的主要原因是什么？
//for c
#include <stdio.h>
int main()
{
const int a=90;
switch(90)
{
case a://error : case label does not reduce to an integer constant
printf("error");
b
浏览 3提问于2020-07-05得票数 1
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
