# Thread: factorials??

1. ## factorials??

I'm a rookie at C++ and trying to learn on my own with a lot of tutorials. My question is, what is the best method of caculating and displaying the values of 1! to 10! using nested "for" statements? Thanks for any advice in advance.

2. You don't really need nested for statments you only need one loop think about it.
a = 1;
for i = 0; i < 10; i++
a = a * i
print a
 thanks hunter ya jerk [/edit]

3. >>for i = 10; i < 10; i++

4. Code:
```/************************************
Calculates factorial of a number (n!)
************************************/
int fact(int n){
int result=1;

//Special cases: n==0 and n<0
if(n==0){return 1;}	//0! = 1
if(n<0)	{return 0;}	//Negative factorial is undefined

//If the number is positive:
while(n>0){
result *=n;
n--;
}
return result;
}```

5. Not entirely relevent, but this was always my favorite:

Code:
```# include <iostream>
using namespace std;

template <int x>
class factorial {
public:
enum { VALUE = x * factorial<x-1>::VALUE };
};

template <>
class factorial<0> {
public:
enum { VALUE = 1 };
};

int main()
{
cout << "Factorial is " << factorial<10>::VALUE << endl;
return 0;
}```

6. You can do it with a recursive function as well, although personally I can't write a recursive function to save my life. There is a tutorial on this site covering recursive functions, but I would never have figured out the output of this without running it:

Code:
```void printnum ( int begin )
{
cout<< begin;

if ( begin < 9 )
printnum ( begin + 1 );

cout<< begin;
}```

7. Hi,

I just thought I'd add a little bit although you probably get the picture now. I have written a complete code which computes n! from n=1 to n=10, like you have mentioned using a 'nested for loop'.

There are easier ways to do it, but I am just doing what you have specified. Underneath is the entire code which can be copied and pasted into your programme straight away.

Code:
```/************************************
Calculates factorial of a number (n!)

from n=1  to n=10
************************************/
#include<iostream.h>

int main()
{
cout<<"*******************************"<<endl;
cout<<"Calculates n! from n=1 to n=10"<<endl;
cout<<"*******************************"<<endl;
cout<<""<<endl;

int accum;

for (int b=1; b<11; b++)
{

accum=1; //initialise accumulate

for (int a=b; a>0; a--)
{
accum=accum*a;
}
cout<<"The solution is: "<<accum<<endl;
}

int stop;
cin>>stop;
}```

8. Thanks everybody for responding. To help me better understand, why did treenef initialize the sample code within the inner loop? I notice if I take this out, you get weird negative numbers. The code in question is:

accum=1; //initialise accumulate

Thanks

9. Actually, it's the outer loop. The outer loop is for displaying the factorial from 1 to 10, and the inner loop is for calculating the factorial of i. Since the accumulator must be reset for each factorial you are calculating, it makes sense to reset it each time at the beginning of the outer loop.

10. Yes hunter is correct.

I should have initialised accum before the nested for statements.
And I should have reset accum at the end of the outer loop. However, I had written the code in a rush and since it worked fine I didn't notice that the logic was incorrect. Here is the ammended code.

Oh and just a helpful hint S_ny 33 -
it's always useful to convert code into flow charts to help you visualise what is going on, especially when it comes to nested statements.

Code:
```/************************************
Calculates factorial of a number (n!)

from n=1  to n=10
************************************/
#include<iostream.h>

int main()
{
cout<<"*******************************"<<endl;
cout<<"Calculates n! from n=1 to n=10"<<endl;
cout<<"*******************************"<<endl;
cout<<""<<endl;

int accum;
accum=1; //initialise accumulate
for (int b=1; b<11; b++)
{

for (int a=b; a>0; a--)
{
accum=accum*a;
}
cout<<"The solution is: "<<accum<<endl;
accum=1;
}

int stop;
cin>>stop;
}```

11. Treenef -- your code is fine and it was very helpful...thanks. The flowchart is a good idea because I think that is my problem when determining the proper outlay of the code. Thanks.

12. >>I should have initialised accum before the nested for statements.
No, it's fine as it is - accum will always be initialized to 1 before being used, and it will be reset when the outer loop wraps around to the beginning again. Either way will work fine though.

13. Okay boys and girls, let's learn something really quick:

You do not need 2 for loops to do something simple like factorials. Usually, 2 for loops would be used to anything involving a 2D array or something of that nature. Also for creating a map or tiles or representing anything in 2 dimensions:
Code:
```for(int i=0; i<height; i++){
cout << endl;
for(int j=0; j<width; j++){
cout << "*";
}
}```
But simple crap like factorials don't need nest for loops. It'll just be more confusing to read, and stupid.

......There's your daily dose of common sense.

14. Originally Posted by Krak
Okay boys and girls, let's learn something really quick:

You do not need 2 for loops to do something simple like factorials. Usually, 2 for loops would be used to anything involving a 2D array or something of that nature. Also for creating a map or tiles or representing anything in 2 dimensions:
Code:
```for(int i=0; i<height; i++){
cout << endl;
for(int j=0; j<width; j++){
cout << "*";
}
}```
But simple crap like factorials don't need nest for loops. It'll just be more confusing to read, and stupid.

......There's your daily dose of common sense.
And, Krak, you should do some reading before posting. The factorial is being calculated in one loop, and the outer loop is to repeat the factorial operation from 1! to 10!. Not the most efficient method to be sure (a single loop from 1 to 10, printing the running product after each iteration as prog-bman suggested, would be ideal but more of a specific-case hack), but the logic is correct and intuitive.

15. Also for creating a map or tiles or representing anything in 2 dimensions:
Wrong.

2 variables for x and y, one for offset. 1 loop and faster than a 2D array.

I should suspect the recursive version would be this:

Code:
```unsigned long Factorial(int num)
{
static unsigned long totalvalue=num;
if (num<2) return totalvalue;

totalvalue*=(num-1);
Factorial(num-1);
}```

Popular pages Recent additions