x86_64汇编中的递归阶乘问题
是指在x86_64架构的汇编语言中，使用递归方法来计算阶乘。
递归是一种通过调用自身的方法来解决问题的技术。在阶乘问题中，递归方法可以通过将问题分解为更小的子问题来计算阶乘。具体而言，递归阶乘问题可以通过以下步骤来解决：
- 定义递归函数：首先，我们需要定义一个递归函数来计算阶乘。该函数接受一个整数作为参数，并返回该整数的阶乘结果。
- 设定终止条件：在递归函数中，我们需要设定一个终止条件，以避免无限递归。在阶乘问题中，终止条件是当输入的整数为0或1时，直接返回1。
- 递归调用：在递归函数中，我们需要调用自身来解决规模更小的子问题。在阶乘问题中，我们可以通过将输入的整数减1，并将其作为参数传递给递归函数来实现。
- 返回结果：最后，我们需要将递归函数的结果返回给调用者。在阶乘问题中，递归函数的返回值即为阶乘结果。
以下是一个示例的x86_64汇编代码，用于计算给定整数的阶乘：
section .data
result db 0
section .text
global _start
_start:
mov eax, 5 ; 输入整数为5
call factorial
mov [result], eax
; 在这里可以使用result变量的值，即为阶乘结果
; 退出程序
mov eax, 1
xor ebx, ebx
int 0x80
factorial:
cmp eax, 1
jle end_factorial
dec eax
push eax
call factorial
pop eax
imul eax, [esp]
add esp, 4
end_factorial:
ret在这个示例代码中，我们使用eax寄存器来存储输入的整数，并调用名为factorial的递归函数来计算阶乘。最终的阶乘结果存储在result变量中。
需要注意的是，以上示例代码仅用于说明递归阶乘问题在x86_64汇编中的实现方式，并不涉及具体的云计算相关内容。
如果您对x86_64汇编中的递归阶乘问题有进一步的疑问或需要了解更多相关知识，可以参考腾讯云的文档和资源：
相关·内容
1回答
所有递归问题背后的原则是分而治之吗？找到阶乘，二进制搜索..。
此外，如何划分和征服范式的工作？，为什么更容易找到阶乘通过递归？
浏览 2提问于2015-01-16得票数 1
回答已采纳
3回答
理解阶乘递归
、、
我正在查看递归的阶乘示例，并希望确保正确理解它！
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n - 1)
我说得对吗：
阶乘(4)=阶乘(4-1) *4 =阶乘(3-1) *3 *4 =阶乘(2-1) *2 *3 *4 =阶乘(1-1) *1 *2 *3 *4= 24
因为阶乘(1-1)=阶乘(0)，作为基本情况显示为=1，然后乘以2，然后是3，然后是4。
这是正确的看法吗？
提前感谢！
浏览 7提问于2014-04-23得票数 4
回答已采纳
10回答
我被这个问题困扰了很长一段时间。我已经设法做了一个递归阶乘。
def factorial(n):
if n == 0:
return 1
else:
return n * factorial(n-1)
双阶乘对于偶数n，双阶乘是所有小于等于n的偶数正整数的乘积；对于奇数p，双阶乘是所有小于等于p的奇数正整数的乘积。
如果n是偶数，则n!! = n*(n - 2)*(n - 4)*(n - 6)* ... *4*2
如果p是奇数，则p!! = p*(p - 2)*(p - 4)*(p - 6)* ... *3*1
但是我不知道做一个双阶乘。
浏览 2提问于2011-01-20得票数 7
3回答
阶乘的递归计算应该很慢，因为问题的复杂性很高。为什么我的基本实现不是很慢呢？我很好奇，因为这应该是一个糟糕的方法的教科书例子。
是因为C#程序中的一些内部优化或缓存导致的吗？
using System;
using System.Diagnostics;
using System.Numerics;
namespace FactorialRecursion
{
class Program
{
static void Main(string[] args)
{
Stopwatch stopwatch = new Stopw
浏览 5提问于2016-09-24得票数 3
1回答
WITH CTE
AS(
SELECT ID,Name,ManagerID, 1 RecursiveCallNumber FROM Employee WHERE ID=2
UNION ALL
SELECT E.ID,E.Name,E.ManagerID,RecursiveCallNumber+1 RecursiveCallNumber FROM Employee E
INNER JOIN CTE ON E.ManagerID=CTE.ID
)
SELECT * FROM CTE
上述代码是如何逻辑工作的？以下是我的解释：
执行第一个select语句。现在，临时表被称为CTE。
执行
浏览 0提问于2015-03-10得票数 1
回答已采纳
2回答
我试图了解下面的C代码在下面是如何工作的：
int factorial(int n) {
int result;
if(n==0){
result=1;
}else{
result = n * factorial(n-1);
}
return result;
}
我知道输出是n的阶乘，我想我试图理解这个递归示例是否使用if语句作为递归的原因。是否也可以使用for循环而不是if来执行递归呢？还是我完全错过了重点？
浏览 3提问于2018-12-10得票数 0
回答已采纳
1回答
递归过程给出分段故障
、、、、
我试着做析因程序，但由于某种原因，它不起作用。
我很抱歉，但我完全不知道问题出在哪里。我试着用gdb进行调试，但是我搞不清楚。
push 4
call Factorial
exit
Factorial:
cmp byte [rsp + 8], 0
jz end
mov eax, [rsp + 8]
mov ebx, eax
dec ebx
im
浏览 7提问于2022-06-09得票数 -1
3回答
这个函数有问题吗？
unsigned long factorial(unsigned long m)
{
return (m == 0) ? 1 : m * factorial(m - 1);
}
如果我添加另一个函数：
int myCombina(int q, int p)
{
return factorial(q) / ( factorial(q) * factorial(q-p) );
}
这个myCombina()不是很有效，因为应该取消其中的最大公约数以找到组合。
max(阶乘(Q)，阶乘(q-p))可以被抵消。我们只需要计算q (q-1) .
浏览 0提问于2011-10-18得票数 0
3回答
假设有一个计算阶乘(N)的函数
阶乘(7)是否为从1到7的n中的每一个创建7个函数对象
并在必要时使用这些值(对于阶乘(8)，就像阶乘(7)*8)
浏览 2提问于2009-03-11得票数 2
回答已采纳
1回答
用递归求和所有阶乘的值。
、、、
我尝试编写一个递归方法，它将所有阶乘的值从0求和到输入数字，并以双倍的形式返回结果。我使用递归阶乘方法来计算各个阶乘。但我不明白如何使所有阶乘递归方法之和的方法使用两个递归，而不是一个递归和for循环。
这是密码！
public static int factorial(int numberinput) {
if (numberinput == 0)
return 1;
else
return (numberinput*factorial(numberinput-1));
}
public static double sum(int num
浏览 4提问于2016-03-09得票数 1
回答已采纳
在这段代码中，我要求用户输入两个整数(Index，Mindex)，然后显示1..Index和1..Mindex之间的所有整数。这里我的问题是，我不知道如何将Index中的Integers和` `Mindex中的Integers相乘，然后将这两个值的乘积相加 with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
procedure Add is
Index, Mindex : Integer;
procedure calc (Item : in
浏览 31提问于2020-10-06得票数 0
我从最基础的东西开始思考递归，因为我过去一直在苦苦挣扎。我正在考虑这个阶乘解决方案：
int Factorial(int n)
{
if (n == 0)
{
return 1;
}
return n * Factorial(n - 1);
}
所以这个函数会一直调用它自己，直到n == 0。然后，它继续在每次调用时返回值。这就是我不明白的地方:当它从基本条件返回时，它返回一个值，并且不断地从每个调用中加值。
这些值存储在哪里，以便最终能够返回总和？
浏览 1提问于2015-09-27得票数 0
6回答
最大递归深度比较
、、、
我编写了这段代码来计算组合的数量：
def fact(n):
return 1 if(n == 1) else n * fact(n - 1)
def combinations(n,k):
return fact(n)/((fact(n - k) * fact(k)))
while(True):
print(combinations(int(input()), int(input())))
阶乘功能似乎运作良好。但是，为什么当我试图找到两个数字的组合时，它给出的最大递归深度超过了比较误差？阶乘函数有什么问题吗，因为这似乎是错误的根源？
这就是我所犯的错误：
bui
浏览 3提问于2013-11-17得票数 4
回答已采纳
1回答
我正在寻找一个阶乘宏的例子。我找不到有用的东西。有什么特别的原因没有呢？这是因为C的实现吗？
所以，为了让问题更清楚.我无法在C的编程语言中找到阶乘宏，我知道在宏中不可能有递归，但是有一种方法可以具有迭代阶乘函数。为什么在C中不可能有一个阶乘宏？
作为参考，我发现了一个阶乘函数迭代实现的示例：
int factorial(int N) {
int product = 1;
for (int j = 1; j <= N; j++)
product *= j;
return product;
}
这是一个问题，以进一步了解C语言及其宏的使用
请解释一下
浏览 3提问于2016-11-22得票数 0
回答已采纳
4回答
迭代阶乘函数：
function factorial($number) {
$result = 1;
while ($number > 0) {
$result *= $number;
$number--;
}
return $result;
}
递归阶乘函数：
function factorial($number) {
if ($number < 2) {
return 1;
} else {
return ($number * factorial($number-1)
浏览 5提问于2012-10-10得票数 25
回答已采纳
1回答
黑客基本功能挑战的其他文本案例
、、、、
我试图解决.The代码，给出正确的解决方案，并通过基本的测试用例，但是，其他两个测试用例失败了。如果这种方法能够通过测试，我们可以使用另一种方法。请帮助我通过其他测试用例，谢谢。这是我的代码：
function factorial(n){
let myNum = n;
let res;
if(myNum === n){
res = myNum * (n -1);
myNum = n - 1;
}
if(myNum > 0){
res = res * (myNum - 1);
my
浏览 6提问于2021-03-31得票数 0
回答已采纳
3回答
我很难实现以下问题的尾递归解决方案：
双阶乘还有另一个递归关系，它也依赖于阶乘，即上面的：(对于n<20)
我必须实现这个方程的递归关系--，我所做的就是上面工作的代码。
long long factorial(int n) {
if (n < 0)
return 0;
if (n < 1)
return 1;
return n * factorial(n - 1);
}
long long doublefactorial(int n) {
if (n < 0)
return
浏览 5提问于2020-04-12得票数 3
2回答
我正在学习js中的递归概念，我得到了一个关于基本代码返回问题的非常基本的问题。
function factorial(n) {
if (n === 1) {
return 1;
}
return n * factorial(n - 1);
}
这是一个简单的阶乘例子来解释递归。
阶乘(5)= 120
我的问题是，当n达到1时，它为什么不返回1？在if语句中返回之后，第二个返回将继续运行吗？如果它返回1，则第二次返回继续运行，它将永远执行5*1(假设n达到5)？
浏览 9提问于2022-04-20得票数 0
1回答
我正在学习Scala中的嵌套函数，下面是一些我遇到问题的代码
object Main extends App {
val fac = (x: Int) => {
val factorial: (Int, Int) => Int = (x, accum) => if (x == 1) accum else factorial(x-1, accum*x)
factorial(x,1)
}
println(fac(3))
}
编译器给出了这个错误：
正向引用超越了值阶乘的定义
val阶乘：( Int，Int) =>
浏览 1提问于2017-08-12得票数 0
回答已采纳
3回答
我正在解决我的家庭作业，不能理解问题，请解释我的问题，以便我可以解决的解决方案。问题是。
编写一个递归函数来计算阶乘，使用除法和征服，就像合并排序一样。即，假设n，写一个函数阶乘(n，m)，计算n(n−1)(n−2)··(m + 1) m，顶层调用为阶乘(n，1)。
帮助我了解以下问题：-
为什么在阶乘函数中有两个论点？
对于给定的问题，如果选择n=8，那么m=5的执行将只像8x7x6x5那样执行。对吗？
就我所读到的解阶乘的方法而言。迭代与递归它们只需输入一个数，即阶乘( n )，即可计算n的值。告诉我怎么开始。
**
浏览 9提问于2014-02-16得票数 2
回答已采纳
1回答
我正在制作一个计算器，并添加了一些更复杂的按钮。我想不通的是阶乘。我知道这是什么，但似乎做不到。当我看着别人的问题时，代码--至少对我来说--不起作用(顺便说一句，这不是一个家庭作业问题)。这是算法周围的一小段代码(这就是它的意思吗？)对于阶乘：
} else if (oper.equals("shriek")) {
resultm.setText("" + answer);
resultl.setText("");
resultr.setText(
浏览 2提问于2012-12-24得票数 2
回答已采纳
我很难理解以下模板定义和模板专门化定义是如何工作的？对我来说，factorial<34>或factorial<T-1>看起来很奇怪！
例如：
factorial<T - 1>::value
意味着什么？
#include <iostream>
template<int T>
struct factorial {
enum { value = factorial<T - 1>::value * T };
};
template<>
struct factorial<1> {
enum {
浏览 1提问于2012-02-01得票数 1
回答已采纳
4回答
递归函数、堆栈溢出和Y组合器
、、、、
我有一个递归函数(在C#中)，我需要调用大约8亿次；这显然会在大约第900次调用后导致堆栈溢出。我已经把它踢到了多个循环中，但是递归模式更容易维护，也更容易维护。
我正在考虑使用y-combinator实现递归函数，从我读到的和看到的情况来看，它应该可以解决堆栈溢出问题，并修复多个嵌套循环。
有人有使用y-combinator的经验吗？我还会被堆栈溢出卡住吗？
以阶乘的简单示例为例。大多数数字的阶乘大于5,000会导致堆栈溢出。如果我在那个场景中正确地使用了y-combinator，它能修复堆栈溢出吗？
它的实现似乎并不简单，所以我想在花费开发精力/资源实现和学习y-combinator之前确
浏览 6提问于2011-12-02得票数 5
回答已采纳
6回答
我刚开始使用java编程，我们的老师教了我们递归的概念，我发现它有点复杂。我只知道它像循环一样工作(就像4的阶乘)，但我仍然不太明白它为什么会那样工作。我能得到关于这个话题的详细解释吗？这是我老师用来解释的一段代码和一张图片。
package javaapplication1;
public class JavaApplication1 {
static int factorial(int n){
int t;
if(n == 0){
return 1;
} else {
t = factorial(n - 1);
r
浏览 4提问于2014-09-25得票数 1
回答已采纳
1回答
我是C编程语言的新手，我正在尝试学习计算给定数字的阶乘的递归。我的问题是，如果我输入'5‘，调试printf语句将打印2,6,24,120。如果函数调用被相应的值替换并一次计算阶乘，它如何打印4次？
#include<stdio.h>
#include<stdlib.h>
int factorial(int n);
int main()
{
int num;
int fact_val;
printf("Enter the number for which you are going to compute
浏览 4提问于2012-08-14得票数 0
回答已采纳
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
回答已采纳
1回答
我尝试使用递归的概念，但使用for do循环。但是我的程序做不到。例如，如果我想输出4！答案应该是24，但我的输出是12。有人能帮我吗？
program pastYear;
var
n,i:integer;
function calculateFactorial ( A:integer):real;
begin
if A=0 then
calculateFactorial := 1.0
else
for i:= A downto 1 do
begin
j:= A-1;
calculateFactori
浏览 5提问于2015-10-22得票数 2
4回答
我正在尝试制作一个计算双阶乘的程序(示例- n=3，=> (3!)！= 6！= 720)，但是递归底部和堆栈溢出异常有一些问题。
public static long df(long n) {
if (n == 1) {
return 1;
} else {
return df(n * df(n - 1));
}
}
public static void main(String[] args) {
System.out.println(df(3));
}
浏览 5提问于2015-11-17得票数 1
#include <iostream>
using namespace std;
int recursiveMinimum(int [], int n);
int main ()
{
int theArray[3] = {1,2,3};
cout << recursiveMinimum(theArray, 0);
cout << endl;
return 0;
}
// pass in array and 0 to indicate first element
// returns smallest number
浏览 6提问于2009-12-18得票数 1
回答已采纳
2回答
我正在尝试理解Haskell中的尾递归。我想我知道它是什么，它是如何工作的，但我想确保我没有把事情搞砸。
下面是“标准”阶乘定义：
factorial 1 = 1
factorial k = k * factorial (k-1)
例如，在运行factorial 3时，我的函数将调用自身3次(要么给它，要么取)。如果我想要计算阶乘99999999，这可能会带来问题，因为我可能会有堆栈溢出。在我到达factorial 1 = 1之后，我将不得不在堆栈中“返回”并将所有值相乘，因此我有6个操作(3个用于调用函数本身，3个用于将值相乘)。
现在，我向您介绍另一种可能的阶乘实现：
factorial
浏览 2提问于2010-11-04得票数 21
回答已采纳
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
回答已采纳
我正在试图编译helloworld.c代码
#include<stdio.h>
int main(){
printf("Hello World");
return 0;
}
在Linux机器上。下面是uname-这是机器的结果，它声明机器是64位。
uname-a : Linux pascal 2.6.32-358.23.2.el6.x86_64 #1 SMP Sat Sep 14 05:32:37 EDT 2013 x86_64 x86_64 x86_64 GNU/Linux
在运行gcc命令时，我得到以下错误：
[pascal]/user/gashar
浏览 1提问于2015-07-30得票数 0
回答已采纳
1回答
我一直在尝试让这个递归阶乘函数在IA32汇编中工作，但我得到的阶乘总是比传入函数的阶乘要少。 例如，5的阶乘是120，但我得到的是24，这是4的阶乘 我目前拥有的是以下内容： public factorial ; int factorial(int N)
factorial: ; {
push ebp ; push return addr
mov ebp, esp ; update SP
mov eax, [e
浏览 18提问于2020-10-26得票数 0
回答已采纳
1回答
问题在于将x86_64 macOS可执行文件静态地链接到libavcodec、libavdevice等，这些文件具有一些针对独立构建的对象文件，因为它们使用了无法在二进制文件中嵌入macOS“标记”的YASM (有关该问题的详细信息，请参阅 )。
在Xcode 11.6下一切正常工作-下面的消息在这里，但它们是警告。使用Xcode 12更新，它们将成为一个错误。怎样再提醒他们一次？我在身份证手册页上找不到任何相关的东西。
ld:在ffmpeg/lib/libavcodec.a(aacencdsp.o)中，为macOS构建，但在为独立构建的对象文件中链接，用于架构x86_64
浏览 1提问于2020-09-19得票数 3
回答已采纳
关于时间复杂度较小的问题，似乎有大量的深度信息:线性、多项式、对数；但是，对于如何容易地确定一个算法是指数的还是阶乘的时间复杂度，没有一个很好的深层信息来源。通常，资源都有关于特定算法的时间复杂度的信息(例如，通过蛮力搜索(即O(n!))解决旅行推销员问题)，但没有确定一个算法是哪种算法的一般方法。有人能给出具体的方法来确定这个问题吗？
浏览 0提问于2017-05-19得票数 1
这篇在caml.inria.fr网站上的文章说..。
与C++和Java不同，O‘opposed中的递归与迭代一样高效
对于类似于阶乘的东西，似乎带有可变变量的循环比递归调用所涉及的堆栈操作更有效。
OCaml真的有比C++和C++更高效的递归机制吗？
浏览 3提问于2014-03-03得票数 0
回答已采纳
1回答
我做了一个简单的阶乘程序：
import sys
sys.set_int_max_str_digits(0)
sys.setrecursionlimit(1000000)
def factorial(x):
if x == 0 | x == 1:
return 1
elif x > 1:
return x * factorial(x - 1)
i = 0
while 1:
print(factorial(i), '\n')
i += 1
但过了一段时间，节目就停止了。我想知道是否有一个方法可以取消限制，
浏览 8提问于2022-10-22得票数 0
我正在尝试将500000的阶乘求值导出到一个文件中，为此我编写了以下程序：
fact(N, NF) :-
fact(1, N, 1, NF).
fact(X, X, F, F) :-
!.
fact(X, N, FX, F) :-
X1 is X + 1,
FX1 is FX * X1,
fact(X1, N, FX1, F).
接下来，我写道：
?- fact(1, 500000, 1, F).
接下来：
?- open('Factorial.txt', write, Stream), write(Stream, $F), close(Str
浏览 4提问于2017-10-29得票数 2
2回答
我试图理解递归，并发现下面的答案是一个免费的freecodecamp递归练习，以因式化一个数字。这是正确的，但我不明白它是如何运行的。
-If‘返回1’退出函数，那么输出不应该是1吗？
-The想要的模式有10x9x8x7等等，但是如果它每次都调用自己，这不是遵循模式10x9、9x8、8x7等等吗？
抱歉，如果这不是一个合适的问题，第一次使用。
function factorialize(num) {
if (num === 0) { return 1; }
return num * factorialize(num-1);
}
factorialize(5);
&g
浏览 1提问于2018-07-19得票数 1
3回答
第一次在这里发帖，希望这个问题可以接受。
作为一个小测试，我编写了一个使用迭代和递归计算数字阶乘的应用程序。这似乎工作得很好，除非要计算大于24的数字的阶乘。
例如，在计算24的阶乘时，两种方法都给出了62044840173323941的正确答案。
然而，在计算25的阶乘时，答案是不同的。递归方法给出的答案是1.5511210043330986e+025，而迭代方法给出的答案是1.5511210043330984e+025。
根据Wolfram Alpha的说法，正确的答案应该与迭代方法相同，那么为什么函数之间存在差异？我问了我的同事，他们也无法解释这种行为。
#define TEST_CAS
浏览 1提问于2013-04-08得票数 5
回答已采纳
我需要通过用户输入找出阶乘数，我已经尝试过这种方法，但我的代码如下：
图中显示了我所面临问题的Factorial代码
浏览 16提问于2018-10-29得票数 0
2回答
我希望有人基本上帮助我理解每一行代码都在做什么，并帮助我注释每一行代码(如果适用的话)，这样它就可以帮助向另一个人解释它在做什么。如果一个人能给出第二次机会并确保代码实际上是好的，那就太棒了--我正试着把我的头放在析因/递归上，并做了一些研究，并找到了这些解决方案。
我被赋予了这样的场景：
对于正n，阶乘为n！=n(n−1)！(例如5！=5*4*3*2* 1)*
下面是我对这个场景的发现：
// Prompt user to enter a number to calculate the factorial
var num = prompt("What number do you wa
浏览 4提问于2016-11-07得票数 1
1回答
Lisp:测量函数的性能
、、、、
到目前为止，在测试编写相同函数的不同方法的速度时，我一直在使用time函数，通常它可以很好地指示不同函数的相对速度(因为它们通常相差大约100k周期)。
然而，在尝试寻找factorial函数的最快方法时，time一直缺乏。这些方法不仅似乎只有10k-30k周期的差异，而且它们的总时间也相差了大约一半(我猜这是预期的)。
factorial的三个函数：
(defun factorial-recusion (n) ; 1st
(if (equal n 1)
1
(* n (factorial (- n 1)))))
(defun factorial
浏览 0提问于2012-07-21得票数 3
回答已采纳
1回答
我创建了这个递归函数来计算一个数字的阶乘。第一个参数n是要计算阶乘的数字，第二个参数result用于在函数调用自身时将阶乘计算的状态传递给函数。我遇到的问题是，函数将在函数的末尾返回正确的阶乘结果，但不会返回它。它将只返回小于2的数字的阶乘，其他所有返回undefined。我有一个条件和"n >=2"，所以我认为这是相关的，但我找不到任何之间的关系和问题。为什么这个函数没有返回正确的阶乘？
function factorial(n, result){
//checks if result is undefined if so uses n calculate v
浏览 16提问于2019-07-16得票数 0
回答已采纳
当我收到这个错误时，这个递归阶乘计算器可以很好地运行到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
回答已采纳
数据类型来保存一个非常大的数字，比如1000或更多数字？我需要找到一个大数字的阶乘，比方说100000000。我的阶乘程序对于较小的数字工作得很好。
long factorial(int x)
{
long fact=1;
if(x<0)
{
System.out.println("Incorrect input, enter a positive number");
fact=0;
}
if(x==0)
fact=1;
if(x>0)
浏览 2提问于2013-07-01得票数 0
4回答
当我在谷歌上搜索“如何找到一个数的阶乘”时，我得到了很多答案。
其中一个例子是...
private double getFactorial(double f){
if ( f == 0 )
return 1;
return (f * getFactorial(f - 1));
}
它起作用了。然而，Windows计算器出乎我的意料:它也适用于十进制数！
例如:在窗口计算器上，0.5的阶乘是0.886226925...
这是我们想要的行为吗？阶乘是为非整数定义的吗？
浏览 3提问于2011-11-26得票数 0
回答已采纳
1回答
function factorial(nb) {
let tab = [];
if (nb > 0) {
tab.push(nb);
tab = tab.concat(factorial(nb - 1));
}
return tab;
}
// Calculate factorial for number 3
const array = factorial(3);
// Calculate the final factorial value by reducing the array
const factorialValue = array.red
浏览 0提问于2023-05-25得票数 2
回答已采纳
5回答
你好，我有一段代码，我是根据其他递归和阶乘程序编写的，但我的问题是，对于它如何存储和保存这个值，并在最后返回它，我感到很困惑。
int factorialfinder(int x)
{
if (x == 1)
{
return 1;
}else
{
return x*factorialfinder(x-1);
}
}
int main()
{
cout << factorialfinder(5) << endl;
}
这样5就进去了，然后被乘以4，一次又一次地调用它的函数，然后它得到一个，然后返
浏览 10提问于2013-08-06得票数 0
回答已采纳
5回答
谁能给我解释一下为什么下面的递归函数的最终返回值是正确的？
function(factorial) {
if (n == 0)
return 1;
return n * factorial (n -1);
}
我理解递归，但我不明白为什么返回值是正确的结果，而不只是1..如果我将return更改为2，那么它只是将factorial的结果加倍。似乎无论我在返回表达式中放入什么值，都会变成阶乘function..Why的累加结果的乘数，是这样吗？阶乘函数的累加结果是如何存储的？感谢所有回复
浏览 1提问于2016-01-20得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
