Q: var factorial = function(n) { var result=n-1; // base case: if (n === 0 ) {return 1;} // recursive case: else if (n >0) { for (var i =1; i <n-1 ; i++){ result = result*i; } return n*result;} }; why i cant pass the second step of challenge? need some help~~~

It's not working because your solution is an *iterative* solution, not a *recursive* solution. A *recursive* solution would involve the function calling itself (Hint: your *recursive* case should fit on one line, and shouldn't have a for loop)

Q: in the next challenge you refer to "base case", what is "base case"?

Base case is where the value of the function is specified in one or more values of the parameter. It is where you ask yourself: Is there a non-recursive way out of the function? Trivial cases of the function. Example: In factorial if n = 0 then n! =1 // non-recursive part or base case otherwise if n>0 ---> n! = (n-1)! // recursive case

Q: Could someone please help me. I made a program for factorial by using C++. At first I did it using the recursion method.But found that the factorial function gives wrong answer for input values of 13, 14 and so on. It works perfectly until 12 as the input. To make sure my program is correct I used iteration method using the "while loop". But that also gave me the same result; incorrect answer after 12. I crosschecked with my calculator (CASIO fx-991MS). But with javascript the function runs perfectly. Here is my program using C++ in codeBlocks: #include <iostream> using namespace std; //using recursion int factorial(int x){ if(x == 0){ return 1; }else{ return x*factorial(x-1); } } //using iteration int Factorial(int x){ int factorialValue = 1; while(x > 0){ factorialValue *= x; x--; } cout << factorialValue << endl; } int main() { //calling for the recursion function cout << factorial(13) << endl; //Calling for the iteration function Factorial(13); return 0; }

The problem is the code above uses the `int` type. The `int` type in C++ is 32 bits, so it only has a range of: -2^31 to 2^31-1 Since 13! is larger than that it starts to overflow and gives crazy answers. Try using the `long long` or `long long int` type which uses 64 bits so it can store numbers from: -2^63 to 2^63-1

Q: How could you simplify this process with larger numbers? For example if I had to calculate 100! , Could I multiply 5! by 20! How do you divide as well?

You could store some of the calculations in an array and access the values when needed. Google dynamic programming if you're interested in optimization.

Q: I'm trying to figure out the results of a python code problem that could be a math problem but if a user inputs a random value of how they want to calculate factorial. Say they put in 11. then after you have dealt with the < 0 and if it == 1 then you have to go thru a range like this; for i in range(1, num + 1): if 5%2 == 0: print("even") else: print("odd") # Python program to find the factorial of a number provided by the user. # change the value for a different result num = 7 # uncomment to take input from the user #num = int(input("Enter a number: ")) factorial = 1 # check if the number is negative, positive or zero if num < 0: print("Sorry, factorial does not exist for negative numbers") elif num == 0: print("The factorial of 0 is 1") else: for i in range(1,num + 1): factorial = factorial*i print("The factorial of",num,"is",factorial) Does this always come out even or is it odd every other one? I am missing something. Please help me to unerstand

All factorials >= 2! are even since they all contain 2 as a factor. Remember that: n! = n * (n-1) * ... * 2 * 1

Question 1

Would it be appropriate to understand this implementation as mathematical induction?

Accepted Answer

Induction and recursion are closely related.

Induction starts from the base case(s) and works up, while recursion starts from the top and works downwards until it hits a base case.

With induction we know we started on a solid foundation of the base cases, but with recursion we have to be careful when we design the algorithm to make sure that we eventually hit a base case.

Often when we want to prove a recursive algorithm is correct we use induction. (We also need to include a proof that the algorithm terminates)

Question 2

why i cant pass the second step of challenge?  need some help~~~

Accepted Answer

It's not working because your solution is an *iterative* solution, not a *recursive* solution.
A *recursive* solution would involve the function calling itself (Hint: your *recursive* case should fit on one line, and shouldn't have a for loop)

Question 3

in the next challenge you refer to "base case", what is "base case"?

Accepted Answer

Base case is where the value of the function is specified in one or more values of the parameter. It is where you ask yourself:  Is there a non-recursive way out of the function?
Trivial cases of the function.
Example:
In factorial if n = 0 then n! =1 // non-recursive part or base case
otherwise if n>0 ---> n! = (n-1)! // recursive case

Question 4

Is it possible to find the factorial value of a negative number? Or is it always 1?

Accepted Answer

What would a negative factorial be? It would just be -(5!), or

-( 5 x 4 x 3 x 2 x 1)

So you could just ignore the negative symbol, and add it at the end.

Question 5

Wait, what makes this any more efficient than the simple algorithm we wrote in the last challenge? This seems unnecessarily complicated.

Accepted Answer

You will find that the implementation is quite simple. This is just a basic example to introduce you to the idea of recursion. In practice you really should not compute factorials recursively.

Question 6

Could someone please help me.

I made a program for factorial by using C++.
At first I did it using the recursion method.But found that the factorial function gives wrong answer for input values of 13, 14 and so on. It works perfectly until 12 as the input.
To make sure my program is correct I used iteration method using the "while loop". But that also gave me the same result; incorrect answer after 12.
I crosschecked with my calculator (CASIO fx-991MS).

But with javascript the function runs perfectly.

Here is my program using C++ in codeBlocks:

#include <iostream>
using namespace std;

//using recursion
int factorial(int x){
if(x == 0){
return 1;
}else{
return x*factorial(x-1);
}

}

//using iteration
int Factorial(int x){
int factorialValue = 1;
while(x > 0){
factorialValue *= x;
x--;
}
cout << factorialValue << endl;

}

int main()
{
//calling for the recursion function
cout << factorial(13) << endl;

//Calling for the iteration function
Factorial(13);

return 0;
}

Accepted Answer

The problem is the code above uses the `int` type. The `int` type in C++ is 32 bits, so it only has a range of:
-2^31 to 2^31-1

Since 13! is larger than that it starts to overflow and gives crazy answers. Try using the `long long` or `long long int` type which uses 64 bits so it can store numbers from:
-2^63 to 2^63-1

Question 7

How could you simplify this process with larger numbers? For example if I had to calculate 100! ,
Could I multiply 5! by 20! How do you divide as well?

Accepted Answer

You could store some of the calculations in an array and access the values when needed.
Google dynamic programming if you're interested in optimization.

Question 8

I'm trying to figure out the results of a python code problem that could be a math problem but if a user inputs a random value of how they want to calculate factorial.  Say they put in 11.  then after you have dealt with the < 0 and if it == 1 then you have to go thru a range like this;

for i in range(1, num + 1):
    if 5%2 == 0:
         print("even")
     else:
          print("odd")
# Python program to find the factorial of a number provided by the user.

# change the value for a different result
num = 7

# uncomment to take input from the user
#num = int(input("Enter a number: "))

factorial = 1

# check if the number is negative, positive or zero
if num < 0:
   print("Sorry, factorial does not exist for negative numbers")
elif num == 0:
   print("The factorial of 0 is 1")
else:
   for i in range(1,num + 1):
       factorial = factorial*i
   print("The factorial of",num,"is",factorial)

Does this always come out even or is it odd every other one?
I am missing something.  Please help me to unerstand

Accepted Answer

All factorials >= 2! are even since they all contain 2 as a factor. Remember that:
 n! = n * (n-1) * ... * 2 * 1

Course: Computer science theory > Unit 1

Recursive factorial

Want to join the conversation?