理解递归canSum函数
递归是一种在编程中常用的技术，它允许函数调用自身来解决问题。递归函数通常包含两个部分：基本情况和递归情况。
在理解递归canSum函数之前，我们先来了解一下递归的概念、分类、优势和应用场景。
概念： 递归是指一个函数通过调用自身来解决问题的过程。在递归过程中，函数会将问题分解为更小的子问题，直到达到基本情况，然后逐步返回结果，最终解决整个问题。
分类： 递归可以分为直接递归和间接递归两种类型。
- 直接递归：函数直接调用自身。
- 间接递归：函数通过调用其他函数，间接地调用自身。
优势： 递归在某些情况下可以提供简洁、优雅的解决方案。它可以将复杂的问题分解为更小的子问题，使得代码更易于理解和维护。递归还可以解决一些数学问题，如阶乘、斐波那契数列等。
应用场景： 递归在许多领域都有广泛的应用，包括算法、数据结构、图形处理、人工智能等。常见的应用场景包括：
- 树和图的遍历
- 排列组合问题
- 动态规划
- 分治算法
- 回溯算法等
下面我们来理解递归canSum函数。
canSum函数是一个用于判断给定数组中是否存在组合和等于目标值的函数。函数的输入参数包括一个目标值target和一个正整数数组numbers。函数的返回值为布尔类型，表示是否存在组合和等于目标值。
以下是一个示例的canSum函数的实现：
def canSum(target, numbers):
# 基本情况
if target == 0:
return True
if target < 0:
return False
# 递归情况
for num in numbers:
remainder = target - num
if canSum(remainder, numbers):
return True
return False该函数的实现思路是通过遍历数组中的每个元素，将目标值减去当前元素，然后递归调用canSum函数判断剩余部分是否存在组合和等于剩余值。如果存在，则返回True；否则，继续遍历数组中的下一个元素。如果遍历完数组后仍未找到组合和等于目标值的情况，则返回False。
该函数的时间复杂度为O(n^m)，其中n为数组的长度，m为目标值的大小。由于存在大量的重复计算，该函数的效率较低。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云函数计算（Serverless）：https://cloud.tencent.com/product/scf
- 腾讯云云服务器（CVM）：https://cloud.tencent.com/product/cvm
- 腾讯云云原生容器服务（TKE）：https://cloud.tencent.com/product/tke
- 腾讯云数据库（TencentDB）：https://cloud.tencent.com/product/cdb
- 腾讯云人工智能（AI）：https://cloud.tencent.com/product/ai
- 腾讯云物联网（IoT）：https://cloud.tencent.com/product/iotexplorer
- 腾讯云移动开发（移动应用托管）：https://cloud.tencent.com/product/baas
- 腾讯云对象存储（COS）：https://cloud.tencent.com/product/cos
- 腾讯云区块链（BCS）：https://cloud.tencent.com/product/bcs
- 腾讯云虚拟专用网络（VPC）：https://cloud.tencent.com/product/vpc
- 腾讯云安全产品：https://cloud.tencent.com/product/security
请注意，以上链接仅供参考，具体产品选择应根据实际需求进行评估和决策。
相关·内容
1回答
我正在解决中的问题4，我还在学习OCaml
问题4如下：
OCaml标准库有List.length，但我们要求您重新实现它。尾部递归解决方案的奖金。
因此，根据我的理解，递归解决方案值得加分，因为它比潜在的更简单、更详细的解决方案更有效。
我想出了一个尾部递归解决方案
let length in_list =
let rec find_len cur_length = function
| [] -> cur_length
| hd::tl -> find_len (cur_length + 1) tl
in find_len 0 in_list
;;
根据
浏览 2提问于2020-04-01得票数 1
回答已采纳
8回答
我最近正在学习编程语言，我想知道编译器在语言本身不允许递归的情况下是如何工作的，比如编译器或运行时检查程序如何确保没有递归。我了解到编译器在翻译代码时不需要理解递归，但是如果不理解它，如何工作呢？我试着考虑分配一个特定的堆栈大小，以避免递归，但我想我不知道如何确定大小。
我假设这不是语言没有递归特性，但编译器或检查器不允许。
浏览 0提问于2022-10-06得票数 13
回答已采纳
5回答
可能重复：
我一直试图将编程中的递归作为一个概念来研究(尽管我正在专门研究Java)，这就是我要理解的最好的方法：
例如，在现实生活中，递归是指我们把两个镜子放在彼此的前面，它们之间产生的图像是递归的。
但我在编程中不懂这个算法？有人能给我一个简单的例子来理解递归吗？
浏览 2提问于2012-11-30得票数 4
回答已采纳
代码：
public static void main(String[] args) {
System.out.println(test(13549));
}
public static int test(int a){
if(a<10)
return a;
int b = (a%10);
int c = test(a/10);
int d = Math.max(b,c);
return d;
}
我理解该方法的作用(在使用调试器之后)，并且我理解该方法调用自身直到它小于10，并且它运行并检查更大的b或c。现在我不
浏览 0提问于2013-03-19得票数 0
1回答
我如何在一个有数字的例子中展示加法是素数递归的。
通过证明，我理解了为什么它是原始递归的，但我就是不能想象它如何以原始递归方式与数字一起工作。
浏览 1提问于2011-09-14得票数 1
1回答
sum_aux函数(显然)是一个尾递归函数。sum也是尾递归函数吗？它只调用sum_aux一次。
否则，我会理解为什么sum_aux是尾递归的，所以不需要解释。
sum_aux(n,i,k) {
if( i <= n ) {
return sum_aux(n,i+1,k+i);
} else {
return k;
}
}
sum(n) {
return sum_aux(n,1,0);
}
浏览 0提问于2019-08-16得票数 0
我正在做一个“用Python自动处理无聊的东西”的小测验，在对这个问题做了一点修改之后，我终于找到了一个有效的解决方案(在我的一个comp好友的帮助下)。小测验要求我制作执行Collatz序列的程序。
除了最后一行之外，我理解所有代码背后的逻辑。
下面是我的代码和一些注释：
def collatz(number):
if number % 2 == 0:
print(number // 2)
return number // 2
elif number % 2 == 1:
print(3 * number + 1)
ret
浏览 1提问于2019-08-07得票数 1
回答已采纳
我想知道是否有人可以帮助我更好地理解递归以及它在PHP中的应用。
也许有一两个真实的例子，告诉我它能给我带来什么好处？
有不同类型的递归吗？
另外，计算机如何知道停止递归呢？递归有没有比其他用法更好的用法？
我应该在什么时候使用它而不是其他方法？
浏览 0提问于2018-01-23得票数 0
8回答
我正在尝试理解递归。具体地说，有两个函数我不能得到。
第一个是我在网上遇到的一个例子：
#include <stdio.h>
void printnum(int begin) {
printf("%d", begin);
if (begin < 9) {
printnum(begin + 1);
}
printf("%d", begin);
}
void main() {
printnum(1);
}
此函数的输出为: 123456789987654321
我可以理解它是如何
浏览 0提问于2014-06-30得票数 1
2回答
我是OOP的新手，尤其是Python，在理解下面的代码时遇到了困难。它用于HackeRank问题。我不知道check是如何在声明中使用的。它应该只返回一个布尔值。
def check(root,mini,maxi):
return(root==None or
(check(root.left,mini,root.data) and
check(root.right,root.data,maxi)))
浏览 0提问于2016-11-19得票数 0
2回答
可能重复: 提高你对递归的理解的资源？
我是一个有两年经验的程序员，有时认为我可以用递归解决一个具体的问题，但在大多数情况下，我失败了。
我正在征求您关于学习、更新和加深递归知识的资源的建议，最好是：
帮助识别何时可以使用递归。
实例(适用于当代编程语言)。
参考手册。
源代码。
浏览 0提问于2012-07-31得票数 2
回答已采纳
7回答
我读过几本书，并通过经验了解到，优化代码到了无法理解的地步，或者想出一个非常快速但非常复杂的解决方案来解决一个问题，在团队工作时，甚至当你自己工作时，甚至在你自己工作的时候，你必须理解你聪明的解决方案，这是不可取的。
我的问题是，应否以同样的方式处理递归？普通程序员是否很容易理解递归，因此应该不受惩罚地使用递归，还是普通程序员对递归不太了解，为了团队的整体生产力，应该远离递归？
我知道有一些简单的答案，“任何不理解递归的程序员都不值一提，所以不要担心它们”，但我想知道，如果你们都有一些真实的经验，你们愿意分享，这将比我刚才提到的观点更能说明这个问题。
浏览 0提问于2010-12-10得票数 8
回答已采纳
当我收到这个错误时，这个递归阶乘计算器可以很好地运行到994的输入："RecursionError:相对地超过了最大递归深度“。有人能解释一下这是什么意思吗？怎么会有最大数量的递归呢？提前谢谢。
def factorial(x):
if( x == 0):
return 1
else:
return x * factorial(x - 1)
while True:
u_input = input("")
print(factorial(int(u_input)))
def calc_factorial(n
浏览 2提问于2016-12-04得票数 1
回答已采纳
5回答
有人能帮我理解这个解决方案吗?我的意思是帮助我迭代所有的东西，这样像我这样愚蠢的人就可以理解它了。非常感谢：
public void recurse(int n, char one, char two, char three)
{
if(n == 1)
System.out.println(n + " " + one + " " + two);
else
{
recur
浏览 0提问于2013-11-01得票数 0
我是代码世界的初学者。我很难理解JavaScript中的递归，尤其是当它需要两个或多个循环时。就像我想用递归打印矩形。我不知道怎么做一个基本的情况，条件，当它还在执行。例如，下面这些代码用于打印矩形或空心矩形。
function box(num) {
for (let i = 0; i < num; i++) {
let str = ''
for (let j = 0; j < num; j++) {
str += '*'
}
console.log(str)
}
}
box(5)
funct
浏览 1提问于2019-01-12得票数 0
回答已采纳
4回答
我目前正在编写一些分而治之的算法，函数递归在任何地方都使用，但是我有非常模糊的概念，或者根本不知道它是如何工作的，这就是为什么我在这里发布它的原因，希望您不要介意它太基本了。
例如，如果我们有以下代码：
#include<iostream>
using namespace std;
void Recursion(int n)
{
cout << n << endl;
if(n > 0)
{
Recursion(n-1);
}
cout<<n<<endl;
}
int main()
{
Recur
浏览 4提问于2013-07-27得票数 5
回答已采纳
2回答
我不能理解当我运行它时，这段代码是如何导致段错误的，有人能帮我理解这是怎么回事吗？
#include <stdio.h>
unsigned long long factorial(unsigned long long x, unsigned long long amt)
{
if (x == 1ULL) return amt;
else return factorial(x-1ULL, amt*x);
}
int main(int argc, char *argv[])
{
for (unsigned long long i = 0; i < 10
浏览 3提问于2016-05-13得票数 1
3回答
public int recursive(int x){
if(x>10){
return x;
}
int y = x + 1;
int r = recursive(y);
System.out.println(y + " Y" + " R" + r + " X " + x);
return r;
}
public static void main(String[] args) {
浏览 5提问于2014-01-30得票数 0
回答已采纳
1回答
我编写这段代码是为了理解一个特定的算法。但我还是不明白递归是如何工作的。有人能给我解释一下吗。我理解输出，直到第5行，它第一次打印“它在这里”，但在那之后，它变得有点令我困惑。守则：
def empty(n):
print("recur ",n)
if(n==1):
print("end")
return(0)
empty(n-1)
print("It got here")
empty(n-1)
当我调用这个函数时
empty(3)
这是我得到的输出
recur 3
r
浏览 2提问于2017-12-11得票数 0
回答已采纳
在下面的代码中，我完全理解它是如何工作的，直到终止和返回1为止。我假设，一旦函数结束，它应该输出1，但它执行的是指数程序应该做的事情，它输出正确的答案，在本例中是9。
我的问题是为什么会这样？
我假设我可视化递归的方式是不正确的(可能是我对堆栈如何处理递归的想法?) ，但是它无助于我的理解的这一点。
function power(base,exponent){
if(exponent === 0){
return 1 // Terminates with return 1 but output is correct
}
return base
浏览 4提问于2015-04-08得票数 1
回答已采纳
2回答
我正在尝试理解下面的代码：
void recursiveReverse(struct node **head_ref)
{
struct node *first;
struct node *rest;
if (*head_ref == NULL)
return;
first = *head_ref;
rest = first->next;
if (rest == NULL)
return;
recursiveReverse(&rest);
first->next
浏览 2提问于2014-12-06得票数 0
2回答
我试图通过使用递归(而不是传统循环)重构一些简单的问题来学习递归。我和指数搏斗。我想不出这是怎么回事。据我所知，还没有为"pow“应该如何处理其参数定义任何数学运算。所以..。从数学上讲，它是如何“知道”如何处理其参数的？有人能帮我理解一下吗？为什么这个计算是正确的，而不以“返回基数*？我做什么-这里做什么？”结束？
function pow(base, exponent) {
if (exponent === 0) {
return 1;
}
return base * pow(base, exponent - 1);
}
pow(2, 3); //->
浏览 4提问于2020-06-17得票数 1
回答已采纳
4回答
听着Scala的课程和解释，我经常听到：“但在实际代码中，我们使用的不是递归，而是尾递归”。
这是否意味着，在我的真实代码中，我不应该使用递归，而应该使用尾部递归，这非常类似于循环，并且不需要史诗短语“为了理解递归，首先需要理解递归”。
实际上，考虑到你的堆栈..。您更可能使用类似循环的尾递归。
我说错了吗？这种“经典的”递归仅仅是为了教育目的，让你的大脑回到过去的大学里吗？
或者，尽管如此，我们还是有地方可以使用它。其中递归调用的深度小于X(其中X为堆栈溢出限制)。或者，我们可以从经典递归开始编码，然后，害怕有一天你的堆栈会被炸开，我们可以使用几个重构来使它像尾巴一样在重构字段中发挥更强大的
浏览 10提问于2013-11-10得票数 15
1回答
我已经试着让它尽可能简单，我仍然在试图理解为什么在下面的例子中递归失败。
#!/bin/sh
foo()
{
echo "Enter a number"
read num
if [ $num -eq 1 ]; then
foo $num
fi
echo "Hi"
sleep 1
}
while true
do
foo
done
只需点击'1‘(你将输入if语句和递归)，你将结束执行"hi“两次，或者直到你输入’1‘的次数。我如何应对这样的问题？
示例执行
Enter a number
1
Enter a number
1
Enter a nu
浏览 0提问于2015-12-30得票数 0
3回答
我对如何“跟踪堆栈深度”感到困惑。实际上，这个问题与我其中一个问题的答案有关。答案是正确的，我理解了，但我不能理解提示。谷歌搜索也没有透露任何有用的信息。顺便说一句，如果这很重要，那么我使用的是Eclipse IDE
浏览 1提问于2012-06-22得票数 1
回答已采纳
int fact(int n){
int result;
if(n==1) return 1;
result=fact(n-1)*n;
return result;
}
那么，如果我调用事实(3)，对于每个调用，结果变量将在堆栈中获得单独的内存？
(如果这是个愚蠢的问题，我很抱歉，但我似乎不能理解这个概念。)
浏览 3提问于2021-04-01得票数 0
回答已采纳
我想用递归计算指数。我有下面的代码，它可以成功地执行。 function pow(base, exponent) {
if (exponent <= 1){
return base
}
else {
return base * pow(base, exponent-1)
}
}
// console.log(pow(3, 5)); // -> answer is 243 在这里，我试图理解else的情况。当指数的输入参数为2或更高时，在else语句中： return base * pow(base, exponent-1)的pow(base,
浏览 29提问于2019-06-15得票数 2
回答已采纳
1回答
我当时正在阅读，并决定尝试在Scala中实现这个想法(我知道它已经在许多功能库中实现了)。不幸的是，我发现原来的论文很难理解，我一开始就停留在某个地方。然后，我找到了更容易理解的，并设法将Haskell代码从论文中重写为Scala，您可以找到它的。然而，我仍然挣扎着去理解以下几分钟：
引用第二篇论文的话
原始Expr数据类型
data Expr = Val Int | Add Expr Expr
新型签名：
data Arith e = Val Int | Add e e
对于任何函子f，其诱导递归数据类型Fix f被定义为f的最小不动点，实现如下：
data Fix f
浏览 0提问于2019-05-06得票数 6
回答已采纳
2回答
当涉及到递归函数时，我正在努力理解python解释器的行为。
以下代码失败并产生意外结果(0,1,2,3,4,5,5,4,5,5,3,4,5....)：
def recur(num):
while num < 6:
print(num)
num+=1
recur(num)
recur(0)
使函数返回解决了问题(1,2,3,4,5)
def recur(num):
while num < 6:
print(num)
num+=1
return recur(num)
r
浏览 4提问于2021-10-31得票数 0
1回答
我正在尝试使用DFS实现“子集”算法。我发现以下两个程序都有效：
def DFS(nums, begin, path, res):
res.append(path[:])
for i in range(begin, len(nums)):
path.append(nums[i])
DFS(nums, i + 1, path, res)
path.pop()
def DFS_2(nums, begin, path, res):
if begin == len(nums):
res.append(path
浏览 1提问于2017-12-25得票数 0
回答已采纳
num=0
def add(n):
global num
num+=n
if n==0:
return num
else:
return add(n-1)
print(add(10000))
我的理解是，对于每个函数调用，它返回另一个函数(递归)，调用“死亡”的函数是因为它“返回”了一些东西。因此，不应该存在堆栈溢出的问题。
但很明显我错了。我哪里错了？
输出if n==0: RecursionError:相对超过最大递归深度
谢谢你！
我知道我最好在这个问题上循环一下，但我只想理解这个概念。
浏览 10提问于2021-01-11得票数 1
回答已采纳
3回答
我目前正在学习Python，并想要澄清迭代函数和递归函数之间的区别。我理解递归函数自称为递归函数，但我不太清楚如何定义迭代函数。
例如，我编写了以下代码
random_list = ['6', 'hello', '10', 'find', '7']
def sum_digits(string):
return sum(int(x) for x in string if x.isdigit())
print "Digits:", sum_digits(random_list)
我认为这是一
浏览 1提问于2018-08-23得票数 0
回答已采纳
2回答
我是新来的Haskell，还在努力理解一些基本知识。在编写递归函数时，我自然地以递归或尾递归的方式编写它们，而不自觉地选择一个而另一个。
我的问题是：
给定任何递归函数，是否有一种简单的方法将其转换为尾递归？
给定一个尾递归函数，是否有一种将其转换为递归的简单方法？
示例函数
addOne [] = []
addOne (x:xs) = (x+1):addOne xs
此外，在编写函数时，如何简单地判断尾递归是否比替代方法更合适？
浏览 0提问于2013-02-24得票数 2
回答已采纳
4回答
下面的代码会导致大'n‘的堆栈溢出，我可以理解其中的原因。
def factorial(n)
(n > 1) ? (return (n * factorial(n - 1))) : (return 1)
end
为什么下面的代码也会导致溢出？
def factorial(n, k)
(n > 1) ? (return factorial(n - 1, lambda {|v| return k.call(v * n)})) : (return k.call(1))
end
浏览 0提问于2009-04-17得票数 7
回答已采纳
3回答
递归调用中的返回语句
、、、
根据我对递归调用的理解，当你通过调用函数来递归时，语句需要是一个返回语句，因为基本上当它弹出函数堆栈时，它会从前面的调用中获得一些值。
我有一些代码，如在BST中插入
insertCorrectLocation(root, newNode) {
if (newNode.data < root.data) {
if (root.left == null) {
root.left = newNode
} else {
return this.insertCorrectLocation(root.left,
浏览 0提问于2019-09-01得票数 2
我正在思考Python，我已经达到了递归，这对我来说是一个很大的痛苦。
，5号，向我展示了这段代码：
def draw(t, length, n):
if n == 0:
return
angle = 50 #sets angle
fd(t, length*n) #make a turtle() "t" go forward length*n pixels while drawing
lt(t, angle) #makes turtle "t" turn left
浏览 3提问于2014-01-10得票数 1
回答已采纳
2回答
我目前正在自学编程，我到了一个被介绍到递归函数的阶段。我理解它们背后的基本原理，但是每当我试图读取包含递归函数的代码时，我都会很难跟踪它们。老实说，如果我不把整个函数写在一张纸上，并且手动地遵循它，我就不能真正理解它的作用，我不能从精神上理解它，这就是我想说的。你能给我一些精神上的建议吗？我相当聪明(智商117 )，也许这就是问题所在？提前谢谢。
浏览 5提问于2017-03-08得票数 0
回答已采纳
4回答
我正在学习数据结构和算法。我发现很难理解递归。所以我有以下问题。但它们与任何特定的代码无关。
当我实现方法时，什么时候/哪里应该考虑递归？
在一般的编码约定中，如果递归和简单迭代都是可行的，我应该更喜欢递归吗？
怎样才能真正理解最可能的递归形式，这样我才能在需要的时候想到它们？学它最好的方法是什么？(有相关的书籍或网站吗？)有什么模式吗？
我知道，如果你觉得递归简单自然，那么这个问题听起来可能毫无建设性。但对我来说，这与我的直觉不一致。我真的很感激你的帮助。
浏览 1提问于2013-09-23得票数 3
回答已采纳
1回答
树中节点的计数
、、、
与f#的战斗-战斗是在树的领域-特别是计算节点的数量。这是真正感兴趣的程序，因为我想最终在F#代码涉及多路树，不幸的是，它已经有了一个有点麻烦的开端-我希望你可以帮助！
99 f#系列中的问题61，要求计算二叉树的叶子。(下面给出的解决方案)计算节点，但我的问题是不理解
双递归是如何向左循环的(有趣的lacc ->循环右.)
cont (branchF x lacc racc)是什么，我的印象是"abc“函数，但这只需要两个参数.
loop t id id的类型是单位-我看不出这是怎么暗示的
基本上不理解这一点，也不理解它在树中的流动顺序(调试和步骤证明没有帮
浏览 3提问于2013-02-26得票数 2
回答已采纳
我试图在F#中将以下普通递归代码转换为尾递归代码，但我失败得很痛苦。
let rec insert elem lst =
match lst with
| [] -> [elem]
| hd::tl -> if hd > elem then
elem::lst
else
hd::(insert elem tl)
let lst1 = []
let lst2 = [1;2;3;5]
printfn "\nInserting
浏览 10提问于2020-11-07得票数 1
最近，我们的老师在JavaScript上给我们做了一个小测验。我在编程方面比较先进，所以当我遇到一个问题时：
在同一函数中使用函数的名称将导致无限循环？
我回答错误是因为递归。根据我的理解，您必须使用函数的名称才能调用它，因此递归将使这种情况并不总是真实的。
我的理解是正确的，还是措辞不同？
浏览 2提问于2016-02-19得票数 3
回答已采纳
有人能给我一点时间来帮助我理解为什么在Lisp中这个小函数一直在评估到真吗？
(defun fob (n)
(if (= n 10)
'true
(fob (+ n 1))))
不断评估跟踪到：
0: (FOB 5)
浏览 0提问于2020-08-13得票数 1
回答已采纳
对于这个论坛来说，这可能有点过于笼统，但希望有人能以一种对我的大脑有意义的方式来解释这一点。我试着阅读和研究，并发现了许多例子-但我仍然不明白“为什么”，这意味着我没有确切地理解一个程序是如何从函数返回回来的。
下面是我编写的一个非常简单的函数，它使用反向递归解决了一个难题。效果很好。
func solver(grid: [[Int]])->[[Int]] {
var returnGrid = constraintPropogation(grid: grid)
if contradictionCheck(grid: returnGrid) == false {
浏览 5提问于2022-03-08得票数 0
我很难理解这段代码。我完全理解foo()为什么要打印这些值，但我无法理解为什么bar()要反向打印这些值。有谁能解释一下这一点吗?这样我就能直观地感觉到它，或者至少给我一个方向去达到赦免的目的。
#include<iostream>
using namespace std;
void bar(int a){
cout<<"bar: "<<a<<endl;
}
void foo(int a){
if(a>0){
a -=1;
cout<<"foo:
浏览 4提问于2020-02-11得票数 6
回答已采纳
1回答
循环递归调用:算法的大O及其步骤
、、、、
我想了解如何评估以下算法的复杂性，大O，以及如何用类似的算法来处理未来的大O估计问题。
#include <iostream>
std::size_t const jobSize = 3;
std::size_t jobCallCounter = 0;
std::size_t jobsDoneCounter = 0;
void doJob( std::size_t jobSize )
{
jobCallCounter++;
for( std::size_t i = 0; i < jobSize; ++i )
{
jobsDoneCo
浏览 1提问于2021-01-14得票数 0
回答已采纳
2回答
我知道这是基本的CS知识，但我仍然不能理解在for循环上执行递归函数的想法。我仍然对递归的概念感到困惑，尤其是在数字方面。假设有一个数字序列3，11，27，59,123.我知道如何计算出数学递归序列，它只是a= An-1 + (8*(n-1))，但不知道如何将其转化为C++递归函数。
有人能勾勒出为上述数列创建递归函数的过程吗？
浏览 5提问于2016-11-29得票数 1
回答已采纳
1回答
我真的很难理解Erlang中的尾递归。
我有以下eunit测试：
db_write_many_test() ->
Db = db:new(),
Db1 = db:write(francesco, london, Db),
Db2 = db:write(lelle, stockholm, Db1),
?assertEqual([{lelle, stockholm},{francesco, london}], Db2).
下面是我的实现：
-module(db) .
-include_lib("eunit/include/eunit.hrl")
浏览 0提问于2010-04-17得票数 2
回答已采纳
云服务器
ICP备案
对象存储
腾讯会议
实时音视频
腾讯云开发者
