计算ln(n!)的java方法递归地
计算ln(n!)的Java方法可以使用递归来实现。首先，我们需要了解ln(n!)的含义。ln(n!)表示n的阶乘的自然对数，即ln(n!) = ln(1) + ln(2) + ln(3) + ... + ln(n)。
下面是一个递归计算ln(n!)的Java方法的示例：
public class FactorialLogarithm {
public static double calculateFactorialLogarithm(int n) {
if (n == 0 || n == 1) {
return 0; // ln(0!) = ln(1!) = 0
} else {
return Math.log(n) + calculateFactorialLogarithm(n - 1);
}
}
public static void main(String[] args) {
int n = 5;
double result = calculateFactorialLogarithm(n);
System.out.println("ln(" + n + "!): " + result);
}
}在上述代码中，calculateFactorialLogarithm方法接收一个整数n作为参数，通过递归调用自身来计算ln(n!)的值。当n为0或1时，直接返回0，因为ln(0!)和ln(1!)的值都为0。对于其他n值，使用Math.log方法计算ln(n)，并将其与递归调用calculateFactorialLogarithm(n - 1)的结果相加。
在main方法中，我们定义了一个n的值为5的示例，并调用calculateFactorialLogarithm方法来计算ln(5!)的值。最后，将结果打印输出。
这个方法可以用于计算任意正整数n的ln(n!)值。
相关·内容
2回答
如何实现java方法递归计算ln(n!)？
这是我的解决方案。我知道这是错误的，但这是到目前为止我想到的唯一解决方案。
double func(int n) {
double result;
if(n == 1)
return 1;
result = func(n-1) * n;
return Math.log(result);
}
下面是该函数返回的内容：
func(2) = 0.6931471805599453 (correct)
func(3) = 0.7320993680864453 (should be: 1.791759469228055000
浏览 43提问于2016-08-25得票数 0
T(1) =1
T(n) = T(n^1/3) +1
我该怎么解决它呢？我说“解决”的意思是发现它的“复杂性”(我真的不知道用英语怎么说)，比如O(nlogn) ecc。
我猜不出替换方法；我对迭代方法一无所获，也不能应用Master定理。
我到了这里，但我不确定：
T(n) =T(n^(1/3^k)) +k
你能给我一些建议吗？
浏览 4提问于2013-06-20得票数 3
回答已采纳
2回答
问题的全部上下文可以在这里看到，。
此外，您还可以尝试我的Sourcecode来绘制小数字的递归：
我用数学的方法来看这个问题，它是一个嵌套递归，如下所示：
Function Find(integer n, function func)
If n=1
For i = 1 to a do func()
Elseif n=2
For i = 1 to b do func()
Else Find(n-1,Find(n-2,func))
Function Main
Find(n,funny)
我在Mathematica中没有模块操作的实现是：
$IterationLimit = I
浏览 1提问于2012-05-03得票数 0
1回答
我正在尝试解决java中的3n+1问题。UVA为我的代码显示运行时错误。我第一次尝试解决问题，但我找不到问题。我测试它与网站上的输入，它works.Is它拒绝，因为我的代码工作缓慢？如果是这样，如何对其进行优化？
PFB我的代码
import java.util.*;
class solution {
public static int[] clength = new int[1000000];
public static long nextnum(long n)
{
if(n%2==0)
{
return n/2;
}
else
浏览 0提问于2015-10-12得票数 1
1回答
在哪种情况下可以在PL/SQL中使用递归
CREATE OR REPLACE FUNCTION factorial (
n POSITIVE
) RETURN POSITIVE
IS
BEGIN
IF n = 1 THEN
RETURN n;
ELSE
RETURN n * factorial(n-1);
END IF;
END;
BEGIN
FOR i IN 1..5 LOOP
DBMS_OUTPUT.PUT_LINE(i || '! = ' || factorial(i));
END LOOP;
END;
这是可行的，但我想知道在
浏览 1提问于2015-03-19得票数 0
1回答
问题:
Utkarsh是个非常健谈的孩子，多次被老师责骂。有一天，老师非常生气，决定给他一个非常严厉的惩罚。他让他站在学校的场地上，那就是X轴。Utkarsh最初位于X= 0。老师要求他跑到X= N，但为了使这个过程更快，Utkarsh决定他只跳2到3步，即从X=S跳到X= S+2或X= S+3，Utkarsh决定用概率P/100跳2步，用概率1-P/100跳3步。您需要在X= N约束条件下找到他精确到达的概率:0
解决方案
我应用了DP使用回忆录使用HashMap，在大输入时，它会在hashmap.containsKey行产生堆栈溢出错误，请告诉我为什么它会显示错误，以及在这里进行回忆录的更
浏览 0提问于2017-07-20得票数 0
回答已采纳
我有一个来计算卢卡斯的数字。如何使我的算法O(n)仍然保持递归？
这就是他给出的暗示：
当考虑到这个问题时，我想我会保留我的主for循环，并使它在计算出的一个数字之前存储这两个数字，但这将是迭代的。
这是我现在的代码：
lucas(n) {
return 2 if n = 0;
return 1 if n = 1;
return lucas(n - 1) + lucas(n - 2);
}
main(String args[]) {
for (int i = 0; i<=10; i++)
print(lucas(i*5));
浏览 9提问于2022-01-31得票数 0
回答已采纳
我得到了“太多级别的符号链接”，我使用的是Java NIO2 :-这是在Unix上运行的。任何想法都会有很大帮助。谢谢。
在我调用的代码的深处
Path currentFolder = Paths.get(currentFolder, date);
在流的某一时刻，我试图得到当前文件夹，如下所示。
public Path getNewFolder() {
return currentFolder.resolve("test").resolve("new");
//where "test" and "new&
浏览 3提问于2014-04-16得票数 0
我试图找到一种在java中计算N^N的有效方法。由于大N的结果非常大，所以我使用BigInteger作为结果数据类型，N是整数。如果N变大，比如N=10000000，那么需要更多的时间来计算结果。有没有有效的方法能在一秒钟内计算出。
浏览 11提问于2013-05-14得票数 3
回答已采纳
如何更好地计算定积分？我使用一个函数进行积分，使用另一个函数递归地查找阶乘。
我喜欢更好的算法，或者效率，甚至是准确性。
public static double testStatistic(double meanTreatmentSumOfSquares, double meanErrorSumOfSquares)
{
return (meanTreatmentSumOfSquares / meanErrorSumOfSquares);
}
public static double pValue(double fStatistic, int
浏览 1提问于2012-07-25得票数 2
回答已采纳
1回答
我正在继续我的任务，理解渐近分析。如果mods愿意的话，最好是写一篇meta post。不管怎么说：
我有两个函数：
f(n) = n^2
g(n) = (log n)^80
来自l‘’Hopitals规则的分析：
lim(n->∞) f(n)/g(n) = f'(n)/g'(n)
这就给我们留下了：
f'(n)/g'(n) = 2n/(80*(log n / √2)
这最终将引导我们到：
0/g''(n) = 0
据我所知，它表明f(n) = o(g(n))
我的理解正确吗？
浏览 35提问于2018-05-28得票数 0
回答已采纳
3回答
java堆栈溢出错误？
、、、
Exception in thread "main" java.lang.StackOverflowError
at Search.mergeSort(Search.java:41)
at Search.mergeSort(Search.java:43)
at Search.mergeSort(Search.java:43)
at Search.mergeSort(Search.java:43)
at Search.mergeSort(Search.java:43)
当我试图运行我的程序时，我一直收到这个错误。我的程序应该从文件中获取字符串输入，并使用此算法对其进行排序。有什么
浏览 3提问于2014-07-11得票数 0
我正在尝试使用memoization打印位置400处的斐波那契数的值。起初，我只能打印到第94个位置的数字，因为我得到了一个整数溢出错误。在线阅读后，我现在可以通过转换为BigInt来打印位置为247的值。但由于某些原因，当我尝试248或更高版本时，我得到了一个巨大的错误。下面是我的代码：
(def m-fib
(memoize (fn [n]
(condp = n
0N 0N
1N 1N
(+ (m-fib (dec n)) (m-fib (- n 2)))))))
(println(m-fib 248N)
浏览 0提问于2016-11-20得票数 2
我试图在java方法中输出两个或多个列表的笛卡儿积，这样我就有了一个列表的列表作为输出。
例如，如果我有：a = [1,2] , b = [3,4] , c = [5,6]，那么输出是：[[1,3,5],[1,3,6],[1,4,5],[1,4,6],[2,3,5],[2,3,6].....]
我已经成功地编写了这段代码，这样它可以用于两个列表，但是当它变成三个或更多时，它就不能工作了。在我的代码中，我最初将前两个列表的笛卡儿积添加到一个更大的列表中。从那以后，我试着把剩下的元素添加到这些列表中，但是由于某种原因，我得到了一个无限循环。
public static List<List&l
浏览 3提问于2019-09-22得票数 2
回答已采纳
4回答
import java.math.BigInteger;
import java.util.HashMap;
/**
*
* @author cypronmaya
*/
public class test {
static HashMap<Integer, BigInteger> cache = new HashMap<Integer, BigInteger>();
public static void main(String[] args) {
System.out.println(factorial(20000));
}
浏览 5提问于2012-02-05得票数 3
回答已采纳
1回答
递归Fib风格的函数变成迭代？
、、、、
我在java中有一个函数，它是用递归算法编写的，需要以迭代的形式编写。问题是，我不知道从哪里开始包装我的思想围绕着一个新的算法。这是我正在做的一项任务。
考虑以下计算问题：
假设你是一名顾问，你有一系列n潜在的咨询工作，分别支付A[0],A[1],..,A[n-1]美元(比如job 0支付A[0]美元，job 1支付A[1]美元，等等)。
此外，job i在i (i = 0 ; : : : ; n 1 )当天开始。
但是，每个作业需要2天，因此您不能连续执行任何两个作业。目标是确定最大金额，用F(n)表示；您可以从从n作业A[0]到A[n-1]选择的有效作业计划中获得收入:例如，考虑以下输
浏览 0提问于2011-10-04得票数 1
回答已采纳
3回答
让我来解释一下这个问题。
我需要写一个程序，在这里我输入一个数字N，然后我必须找到能被所有数字整除到1的最小数字。
例如：。如果我的N是5，答案就是60。60可以被5，4，3，2和1整除。
这是我到目前为止所做的。
import java.util.Scanner;
public class Questão_04 {
public static void main (String [] args)
{
int x = 1, n = 1, d = x % n;
System.out.print("Enter N: ");
Scanner in = n
浏览 0提问于2015-04-21得票数 0
我已经在Eclipse IDE中用Java实现了一个阶乘函数。
public class Utilities {
public static int factorial(int n) {
int result;
if (n <= 1) // base case
return 1;
else {
result = (n * factorial(n - 1));
return result;
}
}
}
在Eclipse的显示中，我检查了Utilities.factorial(6)。然而，我得到了这
浏览 0提问于2012-05-16得票数 7
回答已采纳
if (n<100) {
x = 10;
} else if (n<1000) {
x = 100;
} else if (n<10000) {
x = 1000;
} else if (n....
等等等等。
对于这种类型的问题，有没有一种很好的、简洁的、可伸缩的方法？我的大脑已经决定停止工作了。
浏览 0提问于2011-07-15得票数 4
回答已采纳
1回答
“旅行推销员问题”运行时间的估算
、、、、
“旅行推销员问题”是指一个人必须在"n“个城市之间旅行的问题，但要选择这样的旅行路线：
每个城市只访问一次。
总行程被最小化。
我听说过，如果用“蛮力”(即精确的解决办法)来解决这个问题，如果有超过15个城市，计算机所需的时间将超过一百年！
我有兴趣了解“随着城市数量的增加，我们如何估计计算机解决旅行推销员问题所需的时间(使用”蛮力“)”。例如，来自以下引用()：
，我的问题：，有什么公式可以用来估计一台计算机用“蛮力”解决旅行推销员的时间吗？例如：
N个城市= N！路径
每个都是N！路径将需要"N“计算
因此，计算机将需要N*N计算来检查
浏览 8提问于2022-02-03得票数 0
1回答
该程序读取命令行参数N，并将N! = 1 * 2 * ... * N输出到标准输出。
public class Factorial {
// return n!
// precondition: n >= 0 and n <= 20
public static long factorial(long n) {
if (n < 0) throw new RuntimeException("Underflow error in factorial");
else if (n > 20) throw
浏览 1提问于2013-09-22得票数 0
这是一个使用Java7 ForkJoin的Fibonacci程序。但似乎有一个死锁。
package ForkJoin;
import java.time.LocalTime;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
import static java.time.temporal.ChronoUnit.MILLIS;
class Fibonacci extends RecursiveTask<Integer>{
int num;
浏览 27提问于2018-07-19得票数 1
(这不是一个家庭作业问题。如果有一个课程提供这个问题作为家庭作业，请告诉我，因为我很喜欢它。)
这与相关。
我正在寻找一种实用的算法来计算在大空间中超过p的碰撞概率所需的项数。我需要这个来评估哈希算法在存储大量项目时的适用性。
例如，f(365, .5)应返回23，即任何人拥有相同生日的概率超过0.5的人数。
我已经使用精确的碰撞概率计算创建了一个简单的实现：
def _items_for_p(buckets, p):
"""Return the number of items for chance of collision to exceed p."&
浏览 0提问于2017-09-05得票数 1
3回答
import Control.Monad.State
main = print =<< fmap (`evalState` 0) go where
go :: IO (State Int Int)
go = do
l <- getLine
if null l
then return get
else do
putStrLn (reverse l)
-- another possibility: fmap (modify (+1) >>
浏览 0提问于2015-07-26得票数 6
2回答
我可能犯了一些愚蠢的错误，但每当我试图运行这个程序，它总是给我一个错误的答案。例如，我问Fibonacci序列的第5值是什么，它是7。
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
int n=0;
try{
n= Integer.parseInt(jTextField1.getText());
浏览 2提问于2018-01-13得票数 0
回答已采纳
我使用下面的代码计算斐波纳契序列到任意大的数字。代码按预期工作，直到我要求它调用函数4,000,000次(之前我只运行了几百次)，计算机运行了一小段时间，然后Eclipse中的控制台生成了我粘贴到代码下面的异常。
我的问题是这里到底发生了什么？我的计算机是否完全用完了分配给线程的内存或内存？如果是的话，它为什么要特别停在这个数字上呢？
附加:如何计算斐波纳契序列的进一步数字？
import java.math.BigInteger;
public class fibonacci2 {
public static void main(String[] args) {
calcula
浏览 5提问于2014-08-26得票数 4
回答已采纳
1回答
T(n)=T(n-1) + lgn我的方法是：
代入n-1，n-2，n-3，最终得到T( n) =T(1) +lg2+lg3，因此lg => T(n) = lg(2*3*4*5 n)，因此T(n)= lg (n!)
但他们给出的答案是nlgn。
浏览 1提问于2012-09-10得票数 0
3回答
import java.util.ArrayList;
import java.util.List;
public class WildCardNumber {
public static void main(String[] args) {
List<EvenNumber> le = new ArrayList<>();
List<? extends NaturalNumber> ln = le;
ln.add(new NaturalNumber(50));// * Compile time
浏览 0提问于2014-10-24得票数 2
这是示例代码，我在Java中偶然发现了这个完整的参考，第9版。
// A simple example of recursion.
class Factorial { // this is a recursive method
int fact(int n) {
int result;
if(n==1) return 1;
result = fact(n-1) * n; //This is my question, why not just (n-1)*n?
return result;
} }
class Recur
浏览 7提问于2018-02-28得票数 0
我对递归很陌生，我发现了以下Java问题：
编写一个获得整数n的函数，并打印数字1、2、3！、……、n！。
下面是我所做的工作，我想知道这是否是最简单的解决方案(我不确定，因为我使用了"for“循环来实现它)。
public static void Print(int n) {
if (n == 0) {
System.out.print("1");
} else {
int temp = 1;
for (int i = 1; i <= n, i++) {
temp = temp * i;
}
Print
浏览 0提问于2019-08-23得票数 3
回答已采纳
作为一个学校项目，我试图使用arctan(x)的taylor展开来计算pi的值，如arctan(1) = π/4。我编写了这个程序来计算pi的值，但是我需要非常大的count值来计算它，每当我将限制设置为10000以上的值时，比如说20000，就会得到错误：
Exception in thread "main" java.lang.StackOverflowError
at extended_essay.Talyor_pi_arctan.calculate(Talyor_pi_arctan.java:18)
The line "at extended_essa
浏览 4提问于2016-09-26得票数 2
我有一段代码，我不明白为什么它会在线程"main“java.lang.StackOverflowError中给我异常。
这是一个问题：
Given a positive integer n, prints out the sum of the lengths of the Syracuse
sequence starting in the range of 1 to n inclusive. So, for example, the call:
lengths(3)
will return the the combined length of the sequences:
1
2 1
浏览 1提问于2012-10-07得票数 7
回答已采纳
我正在浏览快速排序的CLRS材料，在分析平均情况时，输入被按1:9的比例拆分。树的高度被给定为log_2 _10/9n。典型的二叉树的最大高度为log_10/9n。我如何得到log_10/9n。这到底是什么意思？
编辑: CLRS 3e Pg 176
浏览 20提问于2018-02-12得票数 0
Fibonacci的正常递推是Fib(N)= Fib(N-1)+Fib(n-2)，它给出了2^N的时间复杂度，为了降低时间复杂度，我们有以下公式：
Fib(N) = [Phi^N – phi^N] / Sqrt[5]
其中Phi= (1 + Sqrt[5]) / 2和phi = (1-Sqrt[5])/2;或phi=Phi-1
我在java中的代码如下：
import java.util.*;
import java.lang.*;
public class Main
{
public static void main(String[] args) {
System
浏览 12提问于2022-04-17得票数 3
1回答
我有以下三个算法，可以给出斐波那契数。我想知道我如何才能找出它们各自的复杂性顺序。有谁知道我是如何确定这一点的？
Method 1
------------------------------------------------------------------------
long long fibb(long long a, long long b, int n) {
return (--n>0)?(fibb(b, a+b, n)):(a);
}
Method 2
------------------------------------------------------
浏览 0提问于2016-02-08得票数 0
1回答
我正在尝试将开放街道地图的纬度/经度转换为像素位置。我在java中找到了这个。当我将代码转换为Delphi时，X结果是正确的，但Y结果略差。
Java代码：
double lon = -89.08805;
double lat = 30.6393;
double zoom = 6; // 6.5156731549786215 would be possible too
double lon_rad = Math.toRadians(lon);
double lat_rad = Math.toRadians(lat);
double n = Math.pow(2.0, zoom);
doub
浏览 16提问于2014-08-18得票数 4
回答已采纳
2回答
自然对数可以用下列公式近似：
ln(x) = 2\sum_{k = 0}^{\infty}\frac{(x-1)^{2k+1}}{(2k+1)(x+1)^{2k+1}}
我已经使用Java实现了这个公式。参数n是近似自然对数的迭代量。
static double lnApproximation(double x, int n) {
double ln = 0;
for (int k = 0; k < n; k++) {
double a = Math.pow(x - 1, 2*k + 1);
doub
浏览 0提问于2020-03-28得票数 8
回答已采纳
我需要使用递归来计算一名运动员获得多少奖牌，例如，如果我输入3枚奖牌，当我在主要测试方法上输入1枚奖牌时，Ex1.(3+(3-1)+3)=(3+2+3)=8/Ex2.(5+(5-1)+5)=(5+4+5)=14会得到8枚奖牌，但是当我更改大于1的数字时，它会崩溃，我得到红色字母作为错误，这是我得到的错误。我已经完成了大约5种递归方法，但我仍然坚持这个方法。
java.lang.StackOverflowError
at RecursiveFunctions.countMedals(RecursiveFunctions.java:87)
public class RecursiveFu
浏览 0提问于2014-02-27得票数 0
回答已采纳
1回答
插图
你正在测试一辆新的无人驾驶汽车，它位于n×n网格的西南角(左下角)。这辆车应该开到对面，东北(右上)，网格的一角.给定n，网格轴的大小，编写一个函数numOfPathsToDest，返回无人驾驶汽车可能走的路径数。为了方便起见，让我们将网格中的每个正方形表示为对(i，j)。对中的第一个坐标表示东西轴，第二个坐标表示南北轴。汽车的初始状态是(0,0)，目的地是(n-1，n-1).汽车必须遵守以下两条规则:它不能越过对角线边界。换句话说，在每一步中，位置(i，j)都需要保持i >= j。请参见上图中的n= 5。在每一步中，它可能向北一个正方形(向上)，或一个正东(右)，但不是两者兼而有
浏览 0提问于2018-05-13得票数 0
谁能告诉我为什么在Java中递归调用的方法应该是静态的？
class abc {
static void fun(int n) {
if (n > 0) {
System.out.println(n);
fun(n - 1);
}
}
public static void main(String args[]) {
int x = 3;
fun(x);
}
}
浏览 37提问于2019-07-29得票数 0
回答已采纳
3回答
二进制空间分割算法的预期运行时间
、、、、
在中，您可以找到以下算法：
BSP(Finite set of finite non-intersecting line segments S)
{
if (n > 1)
{
Use the extension of the first segment in S as the splitting line L
Let S+ and S- be the set of fragments above and below L, respectively
Create a tree T with left subtree = BSP
浏览 8提问于2016-03-14得票数 0
实现了计算N选择r. C(n，r) = C(n-1，r-1) + C(n-1，r)的递归算法.我想计算C(100000,50000)，这就是抛出堆栈溢出。感谢你的帮助。
错误：
java解决方案1 1 10000 5000异常线程“主”java.lang.StackOverflowError at java.lang.System.arraycopy(原生方法) at java.lang.System.arraycopy at java.lang.String.(String.java:215) at java.lang.StringBuilder.toString(StringBuilde
浏览 9提问于2012-10-28得票数 3
我正在做一个计算彩票概率的程序。规格是从47个数字中选择5个，从27个数字中选择1个
因此，我做了以下工作：
#include <iostream>
long int choose(unsigned n, unsigned k);
long int factorial(unsigned n);
int main(){
using namespace std;
long int regularProb, megaProb;
regularProb = choose(47, 5);
megaProb = choose(27, 1);
cout
浏览 1提问于2011-05-10得票数 9
回答已采纳
1回答
要对信号进行频域插值，可以在时域内嵌入零点，并进行FFT。
假设给定向量X中的元素数为N，Y与X相同，但与N<code>E 211</code>零填充。然后，下面给出同样的结果。
$$\hat{x}(k)=\sum_{n=0}^{2N-1} Y(n)e^{i2\pi k n/2N},\quad k=0,...,2N-1,$$
$$\hat{x}(k)=\sum_{n=0}^{ N-1} X(n)e^{i2\pi k n/2N},\quad k=0,...,2N-1.$$
现在，如果我们使用FFTW包，第一个方程需要2N内存空间作为输入向量，而第二个方程只需要N内存空间(
浏览 0提问于2015-03-10得票数 3
回答已采纳
我有一个来自这个文档的代码片段：。
我试图理解这段代码以及它所做的基本工作，以便在c(使用联合)或java或sml，甚至pascal/kotlin中重写它。
有人能给我解释一下这段代码的意思吗？
int eval(Expr n) {
return switch(n) {
case IntExpr(int i) -> i;
case NegExpr(Expr n) -> -eval(n);
case AddExpr(Expr left, Expr right) -> eval(left) + eval(right);
浏览 7提问于2021-11-30得票数 0
回答已采纳
10回答
我一直试图用Java编写一个简单的函数，它可以在不使用循环的情况下计算一个n次方的数字。
然后我找到了Math.pow(a，b)类.或者方法还不能区分这两种理论上的不太好。所以我写了这个..。
public static void main(String[] args) {
int a = 2;
int b = 31;
System.out.println(Math.pow(a, b));
}
然后，我想在不使用循环的情况下制作我自己的Math.pow，我希望它看起来比循环更简单，就像使用某种类型的重复一样，我做了大量的研究，直到我遇到了我尝试使用Str
浏览 7提问于2013-10-17得票数 4
回答已采纳
我试图在Java中找到Fibonacci序列的和，但是运行时间太长了(或者应该这么做吗？)每当我使用超过40的整数时，这个速度就会减慢。
注: 50岁时，会返回一个负值，这会使我感到困惑。
有什么建议吗？
public static void main(String[] args) {
//Find Fibonacci sequence
int sum=getSum(50);
System.out.println("Sum of Fibonacci Numbers is " + sum);
}
static int getSum(int
浏览 5提问于2015-03-24得票数 4
回答已采纳
4回答
我试图编写递归代码来查找正方形网格的所有退出路径，并且在Project4.away(Project4.java:41)处得到一些错误，但我不知道错误是什么，因为下面一行：
在Project4.away(Project4.java:41)
经常被重复，以致错误消息不可见。请帮我找出问题，并解决它。下面是我的逃跑方法。
private static void escape(int row, int col, int[][] swamp,String escapePath)
{
if (row == swamp.length || row==0 || col == 0 ||
浏览 3提问于2013-10-08得票数 1
回答已采纳
3回答
我正在学习递归和理解它的大部分，但是这个特定的例子让我困惑，它是相当基本的，但我不知道哪个语句是基本情况，我认为它是打印行，但很明显可能是错误的。我知道最终的结果是什么，但似乎无法理解它是如何一步一步地做到的。
代码：
private static final String DIGIT_TABLE = "0123456789abcdef";
public static void printIt(long n, int base) {
if(n>=base)
printIt(n / base, base);
System.out.print(DIGIT_TABLE
浏览 0提问于2015-08-16得票数 1
1回答
我在Kotlin中练习递归，并在运行以下两个函数时得到了其他结果：
tailrec fun fac1(n: Long): BigInteger {
if(n == 1L)
return BigInteger.ONE
else
return n.toBigInteger() * fac1(n-1)
}
println("fac1(10000) = ${fac1(10000)}")
Fac1(10000)结果：Exception in thread "main" java.lang.StackOverflowError
浏览 6提问于2021-08-09得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
