Thread: Factorial function ?

This may or may not be what you are looking for:

Code:

Boolean calcFactorial (int n, int* nfact)
{
	int count = n;
        *nfact = 1;

	while(count > 0)
	{
	       *nfact *= count;
		count--;
	}
	return TRUE;
}

int main(int argc, char **argv)
{
	int result;
	int i;

	printf("Input a number: ");
	scanf("%d",&i);

	calcFactorial(i,&result);

	printf("Result of factorial was: %d",result);
	
	return 0;
}

Basically what it does is have a value (result) to be passed in by reference to the factorial function. Then simply start at the n and multiply this by nfact itself until count is equal to 0. I also initialised nfact to 1 in case the variable wasn't initialised previously (which would return garbage if you were to use it before it was initialised).

Also for your original code, you didn't do anything useful in where you stored the calculations. Storing it in result which only has a local scope in the function means that the value will "disappear" after the function loop ends. You could just return result be since you need to have the same parameters as what you specified before this is not really feasible.

Originally Posted by 0rion

You could just return result be since you need to have the same parameters as what you specified before this is not really feasible.

The return value is supposed to be used to determine whether overflow would have occurred, and thus whether any value calculated is valid or not.

[edit]I thought this sounded familiar.

Not if you want to detect overflow.

Code:

#include <stdio.h>

typedef enum { FALSE, TRUE } Boolean;

Boolean calcFactorial (int n, int* nfact)
{
    *nfact = 1;

	while(n > 0)
	{
	       *nfact = *nfact * n;
		   n--;	
	}

	if(*nfact < 0x7fffffff)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

int main()
{
   int value, result;
   for ( value = 0; value < 20; ++value )
   {
      if ( calcFactorial(value,&result) )
      {
         printf("%2d! = %d\n", value, result);
      }
   }
   return 0;
}

/* my output
 0! = 1
 1! = 1
 2! = 2
 3! = 6
 4! = 24
 5! = 120
 6! = 720
 7! = 5040
 8! = 40320
 9! = 362880
10! = 3628800
11! = 39916800
12! = 479001600
13! = 1932053504
14! = 1278945280
15! = 2004310016
16! = 2004189184
17! = -288522240
18! = -898433024
19! = 109641728
*/

[edit]An expected output would be:

Code:

 0! = 1
 1! = 1
 2! = 2
 3! = 6
 4! = 24
 5! = 120
 6! = 720
 7! = 5040
 8! = 40320
 9! = 362880
10! = 3628800
11! = 39916800
12! = 479001600

Originally Posted by koolguysj

The overflow detecting part i can worry later. Right now i just want to work on the correctless of the calculation parts.

You realize that overflow detection is directly related to the correctness?

Heres an one that checks for overflow that uses the implementation from the other forum you posted in:

Code:

#include <limits.h>
#include <stdio.h>

// your other definitions goes here..

Boolean calcFactorial (int n, int* nfact)
{
	int count = n;
	*nfact = 1;
	
	while(count > 0)
	{
		if (*nfact >= INT_MAX / count)
			return FALSE; 
		*nfact *= count;
		count--;
	}
	return TRUE;
}

int main(int argc, char **argv)
{
	int result;
	int i;
	int j;

	printf("Input a number: ");
	scanf("%d",&i);

	j = calcFactorial(i,&result);

        if (j == FALSE)
	{
		fprintf(stderr,"Sorry the input was too large!");
		return 1;
	}

	printf("Result of factorial was: %d",result);
	
	return 0;
}

You simply just have to check the return value and see if it overflowed or not, so if it overflowed then you simply can print a error message to the user saying it was too big or something (what ever you want to do with it).