为什么Array.to_s不是递归的？
Array.to_s不是递归的，是因为to_s方法是Array类的一个实例方法，用于将数组转换为字符串表示形式。该方法并不会递归地遍历数组中的元素，而是直接将数组对象转换为字符串。
to_s方法的实现通常会调用数组对象的inspect方法，该方法会返回一个包含数组元素的字符串表示形式。inspect方法会递归地遍历数组中的元素，并将每个元素转换为字符串。但是to_s方法并不会调用inspect方法，而是直接返回数组对象的字符串表示形式。
因此，如果需要递归地将数组及其元素转换为字符串，可以使用inspect方法而不是to_s方法。例如，可以通过调用array.inspect来获取数组的递归字符串表示形式。
腾讯云相关产品和产品介绍链接地址：
- 云服务器（CVM）：提供可扩展的计算能力，满足各种业务需求。详情请参考：https://cloud.tencent.com/product/cvm
- 云数据库 MySQL 版（CDB）：提供高性能、可扩展的关系型数据库服务。详情请参考：https://cloud.tencent.com/product/cdb_mysql
- 云原生容器服务（TKE）：帮助用户快速构建、部署和管理容器化应用。详情请参考：https://cloud.tencent.com/product/tke
- 人工智能平台（AI Lab）：提供丰富的人工智能算法和模型，帮助用户实现智能化应用。详情请参考：https://cloud.tencent.com/product/ailab
- 物联网开发平台（IoT Explorer）：提供全面的物联网解决方案，帮助用户快速构建物联网应用。详情请参考：https://cloud.tencent.com/product/iothub
- 移动推送服务（信鸽）：提供高效可靠的移动消息推送服务，帮助用户实现消息通知功能。详情请参考：https://cloud.tencent.com/product/xgpush
相关·内容
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
2008年门文件中提出了以下问题：
如果L和L‘(L补)是可递归计数的，那么L是？
( a)定期
( b) CFL
( c) CSL
( d)递归
正确的选项是选项(d)，我接受它是正确的。，但我的问题是为什么不能是常规的还是CSL ?？
因为我认为如果我们考虑L是正则的，那么L'也是正则的(因为正则语言在互补下是封闭的)。现在，由于L'是正则的，所以根据'Chomsky层次结构‘L'也是递归枚举的。即使是常规的L，它也符合问题陈述，那么为什么选项(a)不是正确的选项呢？CSL也是如此，那么为什么选项(c)也不是正确的选择呢？
浏览 12提问于2020-09-30得票数 1
所以，我发现下面的代码不是递归的例子(我不知道在什么地方，但如果我回想起来，我会发布一个链接到它)：
void f() {
f();
}
现在，这是一个调用自身的函数(尽管是无限的)。为什么这不是递归的一个例子呢？这可能不是最好的例子，但为什么他们会说它根本不是递归呢？
浏览 0提问于2012-02-16得票数 1
回答已采纳
1回答
我知道OCaml提供了定义相互递归函数的let rec ... and ...。为什么我不能使用这个表达式来定义相互递归值？
特别是为什么我不能做像let rec x=3 and y=x+5 in x这样的事情，但我能做let rec x=3 and y=[x;4] in y
对于第一种情况，我试着给我一个答案，我认为这是一个有约束力的“问题”，因为值的绑定应该是同时的，所以y不能知道x的值，所以我不能把它加到常量5的值上。这是真的吗？
浏览 0提问于2014-07-15得票数 0
1回答
我只是在玩一个python函数，它会自动改变，无法避免无限的递归。在某种程度上，我做了这样的事情：
def mitsos(a):
global mitsos
def takis(f):
def w(*args, **kargs):
ret = f(*args, **kargs)
return ret + 1
return w
mitsos = takis(mitsos)
return a
这出人意料地奏效了。如果我多次调用mitsos(
浏览 2提问于2017-01-30得票数 0
1回答
所有递归问题背后的原则是分而治之吗？找到阶乘，二进制搜索..。
此外，如何划分和征服范式的工作？，为什么更容易找到阶乘通过递归？
浏览 2提问于2015-01-16得票数 1
回答已采纳
我想知道为什么在Ocaml里，“让..和..”不具有与“类型...和...”相同的作用域：
下面的是OK，t2与t1的作用域相同
# type t1 = t2
and t2 = int;;
下面这个是错误的，v2不在作用域中
# let v1 = v2
and v2 = 3;;
Characters 9-11:
let v1 = v2
^^
Error: Unbound value v2
甚至连"let rec“都不起作用。
# let rec v1 = v2
and v2 = 3;;
Characters 13-15:
let rec v
浏览 0提问于2011-07-18得票数 3
我想使用输入的n=12来运行这段代码，为什么会产生错误？
def rec(n):
if n<4:
return n
temp=n//12
temp=13*temp
sum=rec(temp)
if(sum<=n):
return n
return sum
n=10
n=int(input())
print(rec(n))
浏览 2提问于2017-08-04得票数 0
我是编程的初学者，在这种情况下，我不能理解为什么这段Python代码不能像预期的那样工作。
我试图通过在一个函数中调用一个函数来使用递归；调用该函数n次，并在每次循环时将n减去1到0，在该点上它将停止。
相反，我的代码打印了一次'freak‘，然后我得到了一个'maximum recursion depth’错误消息。
def print_m():
print ('freak')
def do_n(arg, n)):
if n >= 0:
print (do_n(arg,n))
n = n - 1
浏览 2提问于2016-08-31得票数 1
3回答
递归排序列表
、、
在学校，我们学习了递归，这是一个相当容易掌握的概念。但是，理解为什么应该在某些情况下使用它是相当令人困惑的。递归浏览目录或计算阶乘之类的东西是很有意义的，但是我的老师提到递归对排序列表很有好处。
怎么回事？有人能解释我为什么(如果可能的话)你会这么做吗？
提前谢谢。
浏览 0提问于2018-01-23得票数 0
回答已采纳
3回答
任何递归都可以修改为具有堆栈结构的迭代函数，那么我为什么要这样做呢？如果答案是避免堆栈溢出，那么为什么计算机可以通过递归溢出呢？为什么编译器不在默认情况下自动将递归函数放在堆中的堆栈上，或者使用额外的关键字？我知道堆也是有限的，但它比分配给程序的堆栈要大得多。
浏览 0提问于2013-10-23得票数 0
我理解递归函数的问题和堆栈溢出问题的风险。
然而，如果一个函数能够被优化为尾部递归，那么为什么这个优化不自动应用于ie。为什么我需要标记一个可以用@tailrec优化的函数？
浏览 1提问于2016-01-26得票数 4
回答已采纳
为什么我们不能在main中直接使用它？
为什么要有递归呢？
#include<stdio.h>
int factorial(int n);
int main()
{
int n;
printf("Enter an positive integer: ");
scanf("%d",&n);
printf("Factorial of %d = %ld", n, factorial(n));
return 0;
}
int factorial(int n)
{
if(n!=1)
浏览 3提问于2015-11-23得票数 2
回答已采纳
下面，sumAllIf是尾部递归的，而sumAllFold不是。然而，sumAllIf实际上具有相同的实现。这是Scala编译器(或者Scala库)的一个缺点，还是我忽略了什么？
def maybeNext(in: Int): Option[Int] = if in < 10 then Some(in + 1) else None
// The Scala library implements Option.fold like this:
// @inline final def fold[B](ifEmpty: => B)(f: A => B): B =
// if
浏览 5提问于2022-01-23得票数 1
回答已采纳
8回答
递归关系
、
为什么递归阶乘算法的递归关系是这样的？
T(n)=1 for n=0
T(n)=1+T(n-1) for n>0
为什么不是这样呢？
T(n)=1 for n=0
T(n)=n*T(n-1) for n>0
把n的值，即1,2,3,4......第二个递归关系成立(阶乘计算正确)，而不是第一个。
浏览 7提问于2009-09-04得票数 4
回答已采纳
可能重复：
OCaml使用let定义新函数，使用let rec定义递归函数。为什么它需要这两种方法--我们就不能用let来做任何事情吗？
例如，要在OCaml中(实际上，在OCaml解释器中)定义一个非递归的后续函数和递归阶乘，我可以编写
let succ n = n + 1;;
let rec fact n =
if n = 0 then 1 else n * fact (n-1);;
而在Haskell (GHCI)，我可以写
let succ n = n + 1
let fact n =
if n == 0 then 1 else n * fact (n-1
浏览 2提问于2012-02-17得票数 44
回答已采纳
1回答
我有一个简单的函数，它打破一个数字，如54，并返回这两个数字的和(即9)。我也在研究递归，我想知道下面的代码是否符合标准。为什么？或者为什么不呢？如果不是，我如何使用递归范例来解决这个简单的问题？
def sumnum(n):
n = str(n)
a = []
for i in n:
a.append(i)
sum(int(n) for n in a)
sumnum(54)
9
浏览 2提问于2017-05-15得票数 0
回答已采纳
3回答
1.我偶然看到了以下代码：
def search(lst, key):
if not lst: # base case: list is empty
return False
elif lst[0] == key: # base case: current element is searched element
return True
else: # recursive case: advance to next element in list
return search(lst
浏览 3提问于2016-04-30得票数 4
回答已采纳
这里的helper函数是：
def zipWith[B]: (MyList[B], (A, B) => B) => MyList[B] = {
(list, function) => {
def helper: (MyList[B], MyList[A], MyList[B]) => MyList[B] = {
(consList, originalList, modList) =>
val wrapList = if (modList.isEmpty) list else modList
if (origi
浏览 1提问于2022-03-17得票数 0
回答已采纳
1回答
我一直在我的数据结构和算法类中做关于递归的问题，对于一些尾递归函数，我除了让main函数调用helper函数，而helper函数是尾递归部分之外，别无选择，因为我必须传递与原始函数不同的参数。
虽然这在技术上是尾递归的，但原始函数最终处理基本情况，并在主要情况下将附加参数传递给实际的尾递归函数。
显然，这种方式破坏了递归的概念，特别是在家庭作业、考试等的课堂设置中。
这就是为什么今天我想，为什么我不能创建一个辅助函数，而不是一个重载版本的函数，它接受这些额外的参数并继续工作？从技术上讲，它是递归的，因为函数中的所有调用都是对其自身的调用，尽管它具有比初始调用更多的参数。
下面是一个粗略的例子：
浏览 0提问于2011-11-03得票数 2
回答已采纳
2回答
我不明白为什么我的代码可以工作。我没有这段代码的实际应用程序；我只是想知道python中的类。
import sys
sys.setrecursionlimit(20)
class A():
def __init__(self):
self.a = object
def rec(self,argument):
self.a = argument
class B(A):
def __init__(self):
super(B,self).__init__()
self.a = self
myObject =
浏览 0提问于2019-06-13得票数 1
互斥锁是用关键部分实现的，这就是为什么它比OS (在Windows上)要快得多的原因。然而，它没有Windows CRITICAL_SECTION那么快。
在一个线程中，时间只是一个紧密的循环：
423.76ns ATL CMutex
41.74ns std::mutex
16.61ns win32 Critical Section
我的问题是std::mutex还在做什么？我看了消息来源，但无法追踪。然而，在提交给美国竞争情报委员会( Crit Sec )之前，还需要采取额外的措施。我的问题是:完成这些额外步骤有用吗？也就是说，额外的步骤是什么；使用CRITICAL_SECTION会遗漏
浏览 1提问于2015-02-17得票数 8
回答已采纳
2回答
这是尾递归吗？
、、、、
我试图找出尾递归的例子，但我真的看不到规则和尾之间的区别。如果这不是尾递归，有人能告诉我为什么不是吗？
public static long fib(long index) {
// assume index >= 0
if (index == 0) // Base case
return 0;
else
if (index == 1) // Base case
return 1;
else
// Reduction and recursive calls
return fib(index - 1) + fib(index - 2);
浏览 1提问于2013-09-03得票数 4
回答已采纳
我正在学习ANTLR4，我一度感到困惑。对于类似Java的语言，我试图为像成员链这样的构造添加规则，类似于：
expr1.MethodCall(expr2).MethodCall(expr3);
我得到了一个错误，说我的两个规则是相互左递归的：
expression
: literal
| variableReference
| LPAREN expression RPAREN
| statementExpression
| memberAccess
;
memberAccess: expression DOT (methodCall | fi
浏览 3提问于2015-04-01得票数 0
回答已采纳
我在看。我有三个关于JSON.stringify方法的问题。
问题1:
var foo = {
"foundation": "Mozilla",
"model": "box",
"week": 45,
"transport": "car",
"month": 7
},
censor = function (key, value) {
if (typeof value === 'string'
浏览 0提问于2012-04-12得票数 1
回答已采纳
2回答
我最近在学习日期结构。在Mark的书“C中的数据结构和算法分析”中，为什么他说尾递归是递归的糟糕用法，最好不要在第三章中使用它？但我看到很多人说它在网上很有用。
浏览 0提问于2013-09-10得票数 4
回答已采纳
2回答
尾递归:返回语句放置
、、、
虽然我的程序按照我想要的方式工作，但我很好奇为什么当我做了一个小小的改变来去掉一行时，我得到了一个不同的结果？
#include <stdio.h>
int sum(int i);
int main(void)
{
int num;
printf("Enter an integer greater than zero, (q to quit): ");
while (scanf("%d",&num)==1)
{
//Checks if the entered integer is positiv
浏览 1提问于2017-03-01得票数 0
回答已采纳
1回答
所以我对lisp很陌生，我对我遇到的问题感到很困惑：
(defun factorial (x)
(if (>= x 1)
(* x (factorial (- x 1)))
1))
阶乘功能可以输出3000！但是，没有问题
(defun sum (x)
(if (<= x 1)
1
(+ x (sum (- x 1)))))
堆栈溢出在(sum 10000)，我使用clisp。
有人能说明一下为什么会发生这种事吗？
浏览 0提问于2014-03-19得票数 1
回答已采纳
1回答
我输入一个Python程序来找到第n个素数。
def prime(a, b = 2):
def prime(a, b=2):
def gcd(x, y):
if (x % y == 0):
return y
else:
return gcd(x, y - 1)
if (gcd(b, b-1) > 1):
return prime(a, b+1)
elif (a - 1 > 0):
浏览 2提问于2015-11-23得票数 2
回答已采纳
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
为什么中的方法是使用循环而不是通过递归实现的？
浏览 1提问于2019-06-12得票数 2
回答已采纳
为什么DefaultMutableTreeNode中会有一个isRoot()函数？我这样问是因为我有一个扩展DefaultMutableTreeNode的类。我希望能够在多个不同的JTree对象中使用这个类的单个实例。但是，看起来isRoot()是一个我应该问树对象本身的问题。为什么这个函数存在于节点级别而不是树级别，有人能提供一些见解吗？
浏览 3提问于2014-07-25得票数 0
2回答
如果不在这里发布完整的代码，我不太确定如何提出这个问题(这是相当多的代码)，但我会尽我所能。
我有一个实现接口的枚举类。整个程序的目的是在字段中表示一串整数。因此有一个从抽象类AbstractField派生的具体类TrueField，该类实现了一个名为boolean sameAs(Field that)的方法。该方法也存在于enum类中(由于接口的原因，它必须存在)：
enum SimpleField implements Field{
Empty(),Zero(0),Binary(0,1),Unsigned(Integer.MAX_VALUE);
private Field si
浏览 0提问于2015-01-01得票数 1
1回答
我的功能是把一个列表分成两半。
以下是功能：
let rec split = function
| [] -> ([],[])
| [a] -> ([a],[])
| a::b::cs -> let (M,N) = split cs
(a::M, b::N)
我不明白的是，为什么这条语句适用于(a::M, b::N)。我们不是在执行该语句之前调用递归函数吗？所以这句话不应该被执行吗？
浏览 1提问于2017-03-05得票数 3
回答已采纳
1回答
我想用以下代码试用Haskell type和data
type Program a = Maybe a -> (Operation a, Maybe Program a)
data Operation a = Read a | Write a
Program遵循连续传递风格(CPS)，Nothing表示终止。可以用Int或其他东西实例化a。
然而，GHC抱怨说：
main.hs:1:1:
Cycle in type synonym declarations:
main.hs:1:1-58: type Program a =
浏览 2提问于2012-12-06得票数 2
回答已采纳
3回答
递归和不同的列表
、、
虽然不确定这是不是一个有效的问题，但它是这样的。当涉及到不同的列表(linkedList、队列、堆栈等)时，我就有过这样的疑问。和递归算法。我只是不明白我应该在什么时候使用它们，或者为什么要使用它们。我知道如何实现它们，但我真的不确定为什么应该使用列表而不是常规数组，或者为什么应该使用递归而不是for。我再过一年半就要毕业了，我不想在不知道这一点的情况下去找工作。
如果你能给我一个问题的例子，我应该使用它们中的任何一个，我将不胜感激。
浏览 0提问于2012-10-02得票数 1
回答已采纳
在用Antlr编写语法的过程中，我多次遇到过左递归，这就是为什么我问自己为什么没有自动工具来删除它。在我做了一些研究之后，我发现了处理这个问题的两种方法--Paull算法和RobertC.Moore的工作Removing Left Recursion from Context-Free Grammars, 2000中讨论的左角变换。我注意到Paull的算法是一个非常不切实际的算法，但另一方面，左角变换只会增加从O(n)到O(n^2)的语法规则的数量，但是大部分时间都比这低得多，这使得该算法非常高效。因此，我的问题是:左递归删除不是故意实现的，将责任留给语法实现者，还是不被认为是一种选择？
浏览 4提问于2013-08-23得票数 1
回答已采纳
3回答
这是维基百科中可判定的定义。
在可计算性理论中，一个不可判定的问题由一系列需要一个特定的是/否答案的实例组成，这样就没有计算机程序，在给定任何问题实例作为输入后，在有限的步骤之后终止和输出所需的答案。更正式地说，一个不可判定的问题是其语言不是递归集的问题。
递归集是可递归枚举集的子集。有一些递归枚举语言在递归集之外。那么，为什么递归枚举语言不能确定呢？
浏览 3提问于2012-02-26得票数 5
回答已采纳
我最近使用了minidom来解析一些xml文件。
有趣的是，我花了8G内存来读取一个56MB的文件，这是相对平坦的，也就是说，大多数节点都在同一级别。
为什么会这样呢？
浏览 1提问于2013-08-23得票数 1
注意:不是的复制品。我没有使用循环。
(def t
#(let [[low high] (sort %&)] {:low low :high h}))
(t 3 2)
=> {:low 2, :high 3}
考虑到这是预期的工作。为什么这不是：
(def t
#(let [[low high] (sort %&)]
(if (= 0 low)
nil
(do
(println {:low low :high high})
(recur low (dec high))))))
(t 3 2)
浏览 2提问于2012-05-11得票数 4
回答已采纳
fun fold1 f acc lst =
case lst of
[] => acc
| hd::tl => fold1 f (f (acc,hd)) tl
fun fold2 f acc lst =
case lst of
[] => acc
| hd::tl => f (fold2 f acc tl, hd)
为什么第一个是尾递归而另一个不是？
我认为它们都是尾递归的。
浏览 0提问于2018-10-09得票数 0
public void dfsSearch (TreeNode root, List<String> curr, List<List<String>> res) {
curr.add(String.valueOf(root.val));
// a leaf node has been reached
if (root.left == null && root.right == null) {
res.add(curr);
return;
浏览 2提问于2017-03-29得票数 0
回答已采纳
这是我的代码：
x<-c(1,2)
x
names(x)<- c("bob","ed")
x$ed
为什么我会得到以下错误？
x$ed中的错误：$运算符对原子向量无效
浏览 5提问于2014-04-25得票数 95
1回答
我开始使用图形数据库来存储我生成的大图形。但是我不明白为什么要使用图形数据库来完成我的工作，为什么不使用传统的RDBMS来做我想做的事情。具体来说，我的问题是，为什么关系数据库不好，或者更确切地说，图形数据库在存储图形方面比RDBMS更好？
浏览 1提问于2013-04-24得票数 3
回答已采纳
我正在学习F# (函数式编程的一般新手，尽管多年来一直使用C#的函数式方面，但这是非常不同的)，我读到的一件事是F#编译器识别尾递归并将其编译成while循环(请参阅)。
我不明白的是，为什么你要写一个递归函数，而不是一个while循环，如果它无论如何都会变成这样的话。特别是考虑到你需要做一些额外的工作来使你的函数递归。
我有一种感觉，有人可能会说while循环并不是特别有功能性，你想表现出所有的功能性，所以你使用了递归，但是为什么编译器把它变成while循环就足够了呢？
有人能给我解释一下吗？
浏览 3提问于2011-05-07得票数 11
回答已采纳
18回答
迭代比递归更有性能，对吧？那么为什么有些人认为递归比迭代更好(用他们的话说，更优雅)？我真的不明白为什么像Haskell这样的一些语言不允许迭代并鼓励递归？鼓励一些性能不好的东西是不是很荒谬(当有更好的选择，比如递归时也是如此)？请说明一下这一点。谢谢。
浏览 13提问于2010-02-03得票数 62
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
腾讯会议活动推荐
腾讯云开发者
