How do algorithm to find the factorial of a number?

Answer 1

Factorial (n) = n * Factorial (n-1) for all positive values n given Factorial (1) = Factorial (0) = 1.

Pseudo-code:

Function: factorial, f

Argument: positive number, n

IF n<=1 THEN

RETURN 1

ELSE

RETURN n * f(n-1)

END IF

Answer 2

public static final long factorial(final long n) {

if (n <= 1) {
return 1;

}

long _n = n;
for (int i = (int) (n - 1); i > 1; --i) {
_n *= i;

}

return _n;

}

we want an algorithm not code i mean not programing

Answer 3

You get the factorial by multiplying the number with every number before down to 1.

Factorial of 3 would be 3! = 3 * 2 * 1 = 6 or the factorial of 5 would be 5! = 5 * 4 * 3 * 2 * 1 = 120.

Answer 4

The classic algorithm to find N Factorial is ...

int nfact (int n) {

if (n 2) {

decimal_initialize (d, 2);

return;

}

while (N > 2) {

decimal_multiply (d, N);

N--;

}

return;

}

/* Example main line */

int main (int argc, char *argv[]) {

int N;

decimal Decimal = {2, NULL};

if (argc < 2) {

printf ("Enter N (or use command line) : ");

scanf_s ("%d", &N);

} else {

N = atoi (argv[1]);

}

printf ("Arbitrary: %u! = ", N);

decimal_NFactIterative (&Decimal, N);

decimal_print_digits (&Decimal, true);

return 0;

}

Answer 5

The problem with factorials is they get large quickly, and overflow the underlying hardware's capability of representation. The simple example...

unsigned long nfactorial (unsigned long N) return N 2) {

decimal_initialize (d, 2);

return;

}

while (N > 2) {

decimal_multiply (d, N);

N--;

}

return;

}

/* Example main line */

int main (int argc, char *argv[]) {

int N;

decimal Decimal = {2, NULL};

if (argc < 2) {

printf ("Enter N (or use command line) : ");

scanf_s ("%d", &N);

} else {

N = atoi (argv[1]);

}

printf ("Arbitrary: %u! = ", N);

decimal_NFactIterative (&Decimal, N);

decimal_print_digits (&Decimal, true);

return 0;

}

Now, this works well, though for larger numbers you will need to increase your stack size parameter at link time. It also starts to take time. One way to improve that is to store more than one digit in each node of the linked list decimal. You could even store an entire 32 bit word in each element, but the complexity of doing so for this example exceeds the value of the lesson. You would also need to implement a division operator, because you will need to convert to decimal for display purposes.

Answer 6

For any positive integer, n, factorial (n) can be calculated as follows:

- if n<2, return 1.

- otherwise, return n * factorial (n-1).

The algorithm is recursive, where n<2 represents the end-point.

Thus for factorial (5) we find the following recursive steps:

factorial (5) = 5 * factorial (4)

factorial (4) = 4 * factorial (3)

factorial (3) = 3 * factorial (2)

factorial (2) = 2 * factorial (1)

factorial (1) = 1

We've now reached the end-point (1 is less than 2) and the results can now filter back up through the recursions:

factorial (2) = 2 * factorial (1) = 2 * 1 = 2

factorial (3) = 3 * factorial (2) = 3 * 2 = 6

factorial (4) = 4 * factorial (3) = 4 * 6 = 24

factorial (5) = 5 * factorial (4) = 5 * 24 = 120

Thus factorial (5) = 120.

We can also use a non-recursive algorithm. The factorial of both 0 and 1 is 1 thus we know that the return value will always be at least 1. As such, we can initialise the return value with 1. Then we begin iterations; while 1<n, multiply the return value by n and then subtract 1 from n. We can better represent this algorithm using pseudocode:

Function: factorial (n), where n is an integer such that 0<=n. Returns an integer, f.

Let f = 1

Repeat while 1<n

Let f = f * n

Let n = n - 1

End repeat

Return f

Answer 7

Factorial of n:

fac = 1

while n > 1

fac = fac * n

n = n - 1

Answer 8

Recursive Factorial function:

long int factorial(int n)

{

if (n<=1)

return(1);

else

n=n*factorial(n-1);

return(n);

}