0
The simple, trite answer is
unsigned long nfact (int n) {
if (n<=1) return 1; else return n * nfact(n-1);
}
This will quickly overflow, however, because N Factorial quickly gows out of bound of any native data type. A more robust implementation would use a bin technique using linked lists of digits to do the multiplications. Here it is, including comparison between various methods. Note that for large values of N, you may need to increase your linker stack size beyond its default, typically, 1MB...
#include <stdlib.h>
#include <stdio.h>
/* Microsoft 32-bit iterative */
unsigned long NFactLongIterative (unsigned long N) {
unsigned long result = N;
if (N < 2) return 1;
if (N == 2) return 2;
while (--N >= 2) result *= N;
return result;
}
/* Microsoft 64-bit iterative */
unsigned long long NFactLongLongIterative (unsigned long long N) {
unsigned long long result = N;
if (N < 2) return 1;
if (N == 2) return 2;
while (--N >= 2) result *= N;
return result;
}
/* Microsoft 64-bit recursive */
unsigned long long NFactLongLongRecursive (unsigned long long N) {
if (N < 2) return 1;
if (N == 2) return 2;
return N * NFactLongLongRecursive (N - 1);
}
/* Portable double recursive */
double NFactDouble (double N) {
if (N < 2) return 1;
if (N == 2) return 2;
return N * NFactDouble (N - 1);
}
/* Portable arbitrary length decimal iterative */
/* one node of a linked list of digits, the first node being low-order */
struct _decimal {
int digit;
struct _decimal *next;
};
typedef struct _decimal decimal;
/* Portable arbitrary length decimal iterative */
/* Initialize the list - necessary on second pass, if main recoded */
void decimal_initialize (decimal *d, int n) {
decimal *next, *nextsave;
d->digit = n;
nextsave = d->next;
d->next = NULL;
next = nextsave;
while (next != NULL) {
nextsave = next->next;
free (next);
next = nextsave;
}
return;
}
/* Portable arbitrary length decimal iterative */
/* Append a digit at the high order position */
void decimal_add_digit (decimal *d, int n) {
decimal *new_digit = (decimal*) malloc (sizeof (decimal));
while (d->next != NULL) d = d->next;
new_digit->digit = n;
new_digit->next = NULL;
d->next = new_digit;
return;
}
/* Portable arbitrary length decimal iterative */
/* Print the digits in reverse order - recursive */
void decimal_print_digits (decimal *d, int last_digit) {
if (d->next != NULL) decimal_print_digits (d->next, false);
printf ("%d", d->digit);
if (last_digit) printf("\n");
return;
}
/* Portable arbitrary length decimal iterative */
/* multiply the list by N */
void decimal_multiply (decimal *d, int N) {
int carry = 0;
while (d != NULL) {
d->digit = d->digit * N + carry;
carry = d->digit / 10;
d->digit %= 10;
if (carry != 0 && d->next == NULL) decimal_add_digit (d, 0);
d = d->next;
}
return;
}
/* Portable arbitrary length decimal iterative */
/* Primary interative algorithm */
void decimal_NFactIterative (decimal *d, int N) {
if (N < 2) {
decimal_initialize (d, 1);
return;
}
if (N == 2) {
decimal_initialize (d, 2);
return;
}
while (N > 2) {
decimal_multiply (d, N);
N--;
}
return;
}
/* Example main line */
/* Generates all variations to show differences in results */
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 ("Long: %u! = %u\n", N, NFactLongIterative (N));
printf ("LongLong: %u! = %I64u\n", N, NFactLongLongIterative (N));
printf ("Recursive: %u! = %I64u\n", N, NFactLongLongRecursive (N));
printf ("Double: %u! = %.0f\n", N, NFactDouble (N));
/* note: arbitrary is exact - if the others don't match, arithmetic overflow occurred */
printf ("Arbitrary: %u! = ", N);
decimal_NFactIterative (&Decimal, N);
decimal_print_digits (&Decimal, true);
return 0;
}
What else can I help you with?
Write a java program to find the factorial of a given number?
Here's a simple Java program to find the factorial of a given number using a recursive method: import java.util.Scanner; public class Factorial { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.print("Enter a number: "); int number = scanner.nextInt(); System.out.println("Factorial of " + number + " is " + factorial(number)); } static int factorial(int n) { return (n == 0) ? 1 : n * factorial(n - 1); } } This program prompts the user for a number and calculates its factorial recursively.
What is the flowchart and pseudocode for a program that accept and displays the factorial of a number?
A flowchart for a program that accepts and displays the factorial of a number would include the following steps: Start, Input the number, Initialize a variable for the factorial, Use a loop to calculate the factorial by multiplying the variable by each integer up to the number, Output the result, and End. Pseudocode for the same program would look like this: START INPUT number factorial = 1 FOR i FROM 1 TO number DO factorial = factorial * i END FOR OUTPUT factorial END
output of a c program using function to find factorial of a number?
In a C program that calculates the factorial of a number using a function, the program typically prompts the user for an integer input. The function then recursively or iteratively computes the factorial by multiplying the number by the factorial of the number minus one until it reaches one. For example, if the user inputs 5, the program outputs 120, as 5! = 5 × 4 × 3 × 2 × 1. The final result is displayed on the screen.
Program to find the factorial of a number using recursion?
/*program to find the factorial of a given number*/ #include<stdio.h> #include<conio.h> int fact(int); void main() { int n,c; printf("\n enter the number for which you want to find the factorial"); scanf("%d",&n); c=fact(n); printf("\n the factorial of the number %d is %d",n,fact); getch(); } int fact(int n) { int k; if(n==0) return(1); else k=n*fact(n-1); return(k); }
A program for simple factorial in prolog?
In Prolog, a simple factorial program can be defined using recursion. Here's a basic implementation: factorial(0, 1). % Base case: factorial of 0 is 1 factorial(N, Result) :- N > 0, N1 is N - 1, factorial(N1, Result1), Result is N * Result1. % Recursive case You can query the factorial of a number by calling factorial(N, Result). where N is the number you want to compute the factorial for.
Write the Pseudocode to find the factorial of a number?
Pseudo code+factorial
Write a C program to find out factorial if 10?
Here's a simple C program to calculate the factorial of 10: #include <stdio.h> int main() { int i; unsigned long long factorial = 1; // Use unsigned long long for larger results for(i = 1; i <= 10; i++) { factorial *= i; } printf("Factorial of 10 is %llu\n", factorial); return 0; } This program uses a loop to multiply numbers from 1 to 10 and stores the result in factorial, which is then printed.
Program for finding the factorial of the two given number using constructor?
kjhk
C program to find factorial of a no?
this is a code for calculating it recursivelly: float Factorial (float n) { if (n<=1) return 1.0; else return n* Factorial(n-1); }
How do you write a program to factorial in PHP?
To write a program that calculates the factorial of a number in PHP, you can use a recursive function or an iterative approach. Here’s a simple example using a loop: function factorial($n) { $result = 1; for ($i = 2; $i <= $n; $i++) { $result *= $i; } return $result; } echo factorial(5); // Outputs: 120 This code defines a function that multiplies numbers from 2 up to the given number $n to compute the factorial.
Program to find factorial of a number using inheritance?
/*71.PROGRAM TO FIND FACTORIAL OF A NUMBER USING RECURSION*/ #include<stdio.h> #include<conio.h> int fact(int); void main() { int n,f; clrscr(); printf("Enter number whose factorial is to be calculated: "); scanf("%d",&n); if(n>0) { f=fact(n); printf("factorial of %d is %d",n,f); } else printf("Factorial of numbers less than 1 does not exist"); getch(); } int fact(int n) { int facto=1; if(n>1) facto=n*fact(n-1); else return 1; return(facto); }
what is the flow chart and algorithm to find the factorial of a given number?
A flowchart to find the factorial of a given number typically includes the following steps: Start, read the input number, check if the number is less than 0 (return an error for negative numbers), initialize a result variable to 1, and then use a loop to multiply the result by each integer from 1 to the input number. The algorithm can be summarized as follows: if ( n ) is the input number, initialize ( \text{factorial} = 1 ); for ( i ) from 1 to ( n ), update ( \text{factorial} = \text{factorial} \times i ); finally, output the factorial.
