Come trovare un fattoriale?

Come posso scrivere un programma per trovare il fattoriale di un numero naturale?

Questo funzionerà per il fattoriale (anche se un sottoinsieme molto piccolo) di interi positivi:

unsigned long factorial(unsigned long f) { if ( f == 0 ) return 1; return(f * factorial(f - 1)); } printf("%i", factorial(5)); 

A causa della natura del tuo problema (e del livello che hai ammesso), questa soluzione si basa più sul concetto di risolvere questo piuttosto che su una funzione che verrà utilizzata nel prossimo “Motore di Permutazione”.

Questo calcola i fattoriali degli interi non negativi [*] fino a ULONG_MAX, che avrà così tante cifre che è improbabile che la tua macchina possa memorizzare molto di più, anche se ha il tempo di calcolarli. Utilizza la libreria di precisione multipla GNU, a cui è necessario collegarsi.

 #include  #include  #include  #include  void factorial(mpz_t result, unsigned long input) { mpz_set_ui(result, 1); while (input > 1) { mpz_mul_ui(result, result, input--); } } int main() { mpz_t fact; unsigned long input = 0; char *buf; mpz_init(fact); scanf("%lu", &input); factorial(fact, input); buf = malloc(mpz_sizeinbase(fact, 10) + 1); assert(buf); mpz_get_str(buf, 10, fact); printf("%s\n", buf); free(buf); mpz_clear(fact); } 

Esempio di output:

 $ make factorial CFLAGS="-L/bin/ -lcyggmp-3 -pedantic" -B && ./factorial cc -L/bin/ -lcyggmp-3 -pedantic factorial.c -o factorial 100 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000 

[*] Se intendi qualcos’altro con “numero”, dovrai essere più specifico. Non sono a conoscenza di altri numeri per i quali è definito il fattoriale, nonostante i coraggiosi sforzi di Pascal per estendere il dominio utilizzando la funzione Gamma.

Perché farlo in C quando puoi farlo in Haskell :

Programmatore di Freshman Haskell

 fac n = if n == 0 then 1 else n * fac (n-1) 

Sophomore Haskell programmer, al MIT (studiato Scheme come matricola)

 fac = (\(n) -> (if ((==) n 0) then 1 else ((*) n (fac ((-) n 1))))) 

Programmatore Junior Haskell (inizio lettore Peano)

 fac 0 = 1 fac (n+1) = (n+1) * fac n 

Un altro programmatore junior Haskell (leggi che i pattern n + k sono “una parte disgustosa di Haskell” 1 e si uniscono al “Ban n + k patterns” -movement [2])

 fac 0 = 1 fac n = n * fac (n-1) 

Senior programmatore Haskell (votato per Nixon Buchanan Bush – “si appoggia a destra”)

 fac n = foldr (*) 1 [1..n] 

Un altro programmatore senior Haskell (votato per McGovern Biafra Nader – “si appoggia a sinistra”)

 fac n = foldl (*) 1 [1..n] 

Ancora un altro programmatore senior Haskell (si sporse così a destra che tornò di nuovo a sinistra!)

 -- using foldr to simulate foldl fac n = foldr (\xgn -> g (x*n)) id [1..n] 1 

Memoizing Haskell programmer (prende Ginkgo Biloba ogni giorno)

 facs = scanl (*) 1 [1..] fac n = facs !! n 

Programmatore Haskell senza punti (ahem) “Points-free” (studiato a Oxford)

 fac = foldr (*) 1 . enumFromTo 1 

Programmatore iterativo Haskell (ex programmatore Pascal)

 fac n = result (for init next done) where init = (0,1) next (i,m) = (i+1, m * (i+1)) done (i,_) = i==n result (_,m) = m for ind = until dni 

Programmatore iterativo programmatore Haskell (ex programmatore APL e C)

 fac n = snd (until ((>n) . fst) (\(i,m) -> (i+1, i*m)) (1,1)) 

Accumulare il programmatore di Haskell (costruendo un climax veloce)

 facAcc a 0 = a facAcc an = facAcc (n*a) (n-1) fac = facAcc 1 

Programmatore Haskell che passa per la continuazione (CONIGLIETTI cresciuti nei primi anni, poi trasferito nel New Jersey)

 facCps k 0 = k 1 facCps kn = facCps (k . (n *)) (n-1) fac = facCps id 

Boy Scout Haskell programmatore (ama bind i nodes, sempre “riverente”, appartiene alla Chiesa del Minimo Punto Fisso [8])

 yf = f (yf) fac = y (\fn -> if (n==0) then 1 else n * f (n-1)) 

Programmatore combinatorio Haskell (evita le variabili, se non l’offuscamento, tutto questo curry è solo una fase, anche se raramente lo ostacola)

 sfgx = fx (gx) kxy = x bfgx = f (gx) cfgx = fxg yf = f (yf) cond pfgx = if px then fx else gx fac = y (b (cond ((==) 0) (k 1)) (b (s (*)) (cb pred))) 

Programmatore haskell codifica di liste (preferisce contare in unario)

 arb = () -- "undefined" is also a good RHS, as is "arb" :) listenc n = replicate n arb listprj f = length . f . listenc listprod xs ys = [ i (x,y) | x<-xs, y<-ys ] where i _ = arb facl [] = listenc 1 facl [email protected](_:pred) = listprod n (facl pred) fac = listprj facl 

Programmatore Haskell interpretativo (mai "incontrato un linguaggio" che non gli piaceva)

 -- a dynamically-typed term language data Term = Occ Var | Use Prim | Lit Integer | App Term Term | Abs Var Term | Rec Var Term type Var = String type Prim = String -- a domain of values, including functions data Value = Num Integer | Bool Bool | Fun (Value -> Value) instance Show Value where show (Num n) = show n show (Bool b) = show b show (Fun _) = "" prjFun (Fun f) = f prjFun _ = error "bad function value" prjNum (Num n) = n prjNum _ = error "bad numeric value" prjBool (Bool b) = b prjBool _ = error "bad boolean value" binOp inj f = Fun (\i -> (Fun (\j -> inj (f (prjNum i) (prjNum j))))) -- environments mapping variables to values type Env = [(Var, Value)] getval x env = case lookup x env of Just v -> v Nothing -> error ("no value for " ++ x) -- an environment-based evaluation function eval env (Occ x) = getval x env eval env (Use c) = getval c prims eval env (Lit k) = Num k eval env (App mn) = prjFun (eval env m) (eval env n) eval env (Abs xm) = Fun (\v -> eval ((x,v) : env) m) eval env (Rec xm) = f where f = eval ((x,f) : env) m -- a (fixed) "environment" of language primitives times = binOp Num (*) minus = binOp Num (-) equal = binOp Bool (==) cond = Fun (\b -> Fun (\x -> Fun (\y -> if (prjBool b) then x else y))) prims = [ ("*", times), ("-", minus), ("==", equal), ("if", cond) ] -- a term representing factorial and a "wrapper" for evaluation facTerm = Rec "f" (Abs "n" (App (App (App (Use "if") (App (App (Use "==") (Occ "n")) (Lit 0))) (Lit 1)) (App (App (Use "*") (Occ "n")) (App (Occ "f") (App (App (Use "-") (Occ "n")) (Lit 1)))))) fac n = prjNum (eval [] (App facTerm (Lit n))) 

Programmatore statico di Haskell (lo fa con la class, ha quel fondo Jones! Dopo Thomas Hallgren "Fun with Functional Dependencies" [7])

 -- static Peano constructors and numerals data Zero data Succ n type One = Succ Zero type Two = Succ One type Three = Succ Two type Four = Succ Three -- dynamic representatives for static Peanos zero = undefined :: Zero one = undefined :: One two = undefined :: Two three = undefined :: Three four = undefined :: Four -- addition, a la Prolog class Add abc | ab -> c where add :: a -> b -> c instance Add Zero bb instance Add abc => Add (Succ a) b (Succ c) -- multiplication, a la Prolog class Mul abc | ab -> c where mul :: a -> b -> c instance Mul Zero b Zero instance (Mul abc, Add bcd) => Mul (Succ a) bd -- factorial, a la Prolog class Fac ab | a -> b where fac :: a -> b instance Fac Zero One instance (Fac nk, Mul (Succ n) km) => Fac (Succ n) m -- try, for "instance" (sorry): -- -- :t fac four 

Programmatore principiante Haskell (l'istruzione post-laurea tende a liberare uno da piccole preoccupazioni circa, ad esempio, l'efficienza dei numeri interi basati su hardware)

 -- the natural numbers, a la Peano data Nat = Zero | Succ Nat -- iteration and some applications iter zs Zero = z iter zs (Succ n) = s (iter zsn) plus n = iter n Succ mult n = iter Zero (plus n) -- primitive recursion primrec zs Zero = z primrec zs (Succ n) = sn (primrec zsn) -- two versions of factorial fac = snd . iter (one, one) (\(a,b) -> (Succ a, mult ab)) fac' = primrec one (mult . Succ) -- for convenience and testing (try eg "fac five") int = iter 0 (1+) instance Show Nat where show = show . int (zero : one : two : three : four : five : _) = iterate Succ Zero Origamist Haskell programmer (always starts out with the “basic Bird fold”) -- (curried, list) fold and an application fold cn [] = n fold cn (x:xs) = cx (fold cn xs) prod = fold (*) 1 -- (curried, boolean-based, list) unfold and an application unfold pfgx = if px then [] else fx : unfold pfg (gx) downfrom = unfold (==0) id pred -- hylomorphisms, as-is or "unfolded" (ouch! sorry ...) refold cnpfg = fold cn . unfold pfg refold' cnpfgx = if px then n else c (fx) (refold' cnpfg (gx)) -- several versions of factorial, all (extensionally) equivalent fac = prod . downfrom fac' = refold (*) 1 (==0) id pred fac'' = refold' (*) 1 (==0) id pred 

Programmatore Haskell incline alle scorte cartesiane (preferisce il cibo greco, evita il piccante indiano, ispirato a "Sorting Morphisms" di Lex Augusteijn [3])

 -- (product-based, list) catamorphisms and an application cata (n,c) [] = n cata (n,c) (x:xs) = c (x, cata (n,c) xs) mult = uncurry (*) prod = cata (1, mult) -- (co-product-based, list) anamorphisms and an application ana f = either (const []) (cons . pair (id, ana f)) . f cons = uncurry (:) downfrom = ana uncount uncount 0 = Left () uncount n = Right (n, n-1) -- two variations on list hylomorphisms hylo fg = cata g . ana f hylo' f (n,c) = either (const n) (c . pair (id, hylo' f (c,n))) . f pair (f,g) (x,y) = (fx, gy) -- several versions of factorial, all (extensionally) equivalent fac = prod . downfrom fac' = hylo uncount (1, mult) fac'' = hylo' uncount (1, mult) 

Ph.D. Programmatore Haskell (mangiò così tante banane che i suoi occhi andarono a sbattere fuori, ora ha bisogno di nuovi obiettivi!)

 -- explicit type recursion based on functors newtype Mu f = Mu (f (Mu f)) deriving Show in x = Mu x out (Mu x) = x -- cata- and ana-morphisms, now for *arbitrary* (regular) base functors cata phi = phi . fmap (cata phi) . out ana psi = in . fmap (ana psi) . psi -- base functor and data type for natural numbers, -- using a curried elimination operator data N b = Zero | Succ b deriving Show instance Functor N where fmap f = nelim Zero (Succ . f) nelim zs Zero = z nelim zs (Succ n) = sn type Nat = Mu N -- conversion to internal numbers, conveniences and applications int = cata (nelim 0 (1+)) instance Show Nat where show = show . int zero = in Zero suck = in . Succ -- pardon my "French" (Prelude conflict) plus n = cata (nelim n suck ) mult n = cata (nelim zero (plus n)) -- base functor and data type for lists data L ab = Nil | Cons ab deriving Show instance Functor (L a) where fmap f = lelim Nil (\ab -> Cons a (fb)) lelim nc Nil = n lelim nc (Cons ab) = cab type List a = Mu (L a) -- conversion to internal lists, conveniences and applications list = cata (lelim [] (:)) instance Show a => Show (List a) where show = show . list prod = cata (lelim (suck zero) mult) upto = ana (nelim Nil (diag (Cons . suck)) . out) diag fx = fxx fac = prod . upto Post-doc Haskell programmer (from Uustalu, Vene and Pardo's “Recursion Schemes from Comonads” [4]) -- explicit type recursion with functors and catamorphisms newtype Mu f = In (f (Mu f)) unIn (In x) = x cata phi = phi . fmap (cata phi) . unIn -- base functor and data type for natural numbers, -- using locally-defined "eliminators" data N c = Z | S c instance Functor N where fmap g Z = Z fmap g (S x) = S (gx) type Nat = Mu N zero = In Z suck n = In (S n) add m = cata phi where phi Z = m phi (S f) = suck f mult m = cata phi where phi Z = zero phi (S f) = add mf -- explicit products and their functorial action data Prod ec = Pair ce outl (Pair xy) = x outr (Pair xy) = y fork fgx = Pair (fx) (gx) instance Functor (Prod e) where fmap g = fork (g . outl) outr -- comonads, the categorical "opposite" of monads class Functor n => Comonad n where extr :: na -> a dupl :: na -> n (na) instance Comonad (Prod e) where extr = outl dupl = fork id outr -- generalized catamorphisms, zygomorphisms and paramorphisms gcata :: (Functor f, Comonad n) => (forall a. f (na) -> n (fa)) -> (f (nc) -> c) -> Mu f -> c gcata dist phi = extr . cata (fmap phi . dist . fmap dupl) zygo chi = gcata (fork (fmap outl) (chi . fmap outr)) para :: Functor f => (f (Prod (Mu f) c) -> c) -> Mu f -> c para = zygo In -- factorial, the *hard* way! fac = para phi where phi Z = suck zero phi (S (Pair fn)) = mult f (suck n) -- for convenience and testing int = cata phi where phi Z = 0 phi (S f) = 1 + f instance Show (Mu N) where show = show . int 

Professore di ruolo (insegnando Haskell alle matricole)

 fac n = product [1..n] 

Grazie a Christoph, una soluzione C99 che funziona per un bel po ‘di “numeri”:

 #include  #include  double fact(double x) { return tgamma(x+1.); } int main() { printf("%f %f\n", fact(3.0), fact(5.0)); return 0; } 

produce 6,000000 120,000000

Per grandi n potresti incontrare alcuni problemi e potresti voler usare l’approssimazione di Stirling:

Che è:

alt text

Se il tuo objective principale è una funzione dall’aspetto interessante:

 int facorial(int a) { int b = 1, c, d, e; a--; for (c = a; c > 0; c--) for (d = b; d > 0; d--) for (e = c; e > 0; e--) b++; return b; } 

(Non consigliato come algoritmo per l’uso reale).

una versione ricorsiva della coda:

 long factorial(long n) { return tr_fact(n, 1); } static long tr_fact(long n, long result) { if(n==1) return result; else return tr_fact(n-1, n*result); } 

In C99 (o Java) scriverei la funzione fattoriale in modo simile a questo:

 int factorial(int n) { int result = 1; for (int i = 2; i <= n; i++) { result *= i; } return result; } 
  • C non è un linguaggio funzionale e non è ansible fare affidamento sull'ottimizzazione di coda. Quindi non usare la ricorsione in C (o Java) a meno che non sia necessario.

  • Solo perché factorial è spesso utilizzato come primo esempio di ricorsione, non significa che sia necessario ricorsività per calcolarlo.

  • Questo si riverserà in modo silenzioso se n è troppo grande, come è consuetudine in C (e Java).

  • Se i numeri int possono rappresentare troppo piccoli per i fattoriali che vuoi calcolare, scegli un altro tipo di numero. lunga se è necessario un po 'più grande, fluttua o raddoppia se n non è troppo grande e non ti importa qualche imprecisione, o grandi numeri interi se vuoi i valori esatti di fattoriali davvero grandi.

Ecco un programma C che utilizza l’implementazione di BIGNUM di OPENSSL e quindi non è particolarmente utile per gli studenti. (Ovviamente accettando un BIGNUM come parametro di input è pazzesco, ma utile per dimostrare l’interazione tra BIGNUM).

 #include  #include  #include  #include  #include  BIGNUM *factorial(const BIGNUM *num) { BIGNUM *count = BN_new(); BIGNUM *fact = NULL; BN_CTX *ctx = NULL; BN_one(count); if( BN_cmp(num, BN_value_one()) <= 0 ) { return count; } ctx = BN_CTX_new(); fact = BN_dup(num); BN_sub(count, fact, BN_value_one()); while( BN_cmp(count, BN_value_one()) > 0 ) { BN_mul(fact, count, fact, ctx); BN_sub(count, count, BN_value_one()); } BN_CTX_free(ctx); BN_free(count); return fact; } 

Questo programma di test mostra come creare un numero per l’input e cosa fare con il valore restituito:

 int main(int argc, char *argv[]) { const char *test_cases[] = { "0", "1", "1", "1", "4", "24", "15", "1307674368000", "30", "265252859812191058636308480000000", "56", "710998587804863451854045647463724949736497978881168458687447040000000000000", NULL, NULL }; int index = 0; BIGNUM *bn = NULL; BIGNUM *fact = NULL; char *result_str = NULL; for( index = 0; test_cases[index] != NULL; index += 2 ) { BN_dec2bn(&bn, test_cases[index]); fact = factorial(bn); result_str = BN_bn2dec(fact); printf("%3s: %s\n", test_cases[index], result_str); assert(strcmp(result_str, test_cases[index + 1]) == 0); OPENSSL_free(result_str); BN_free(fact); BN_free(bn); bn = NULL; } return 0; } 

Compilato con gcc:

 gcc factorial.c -o factorial -g -lcrypto 
 int factorial(int n){ return n <= 1 ? 1 : n * factorial(n-1); } 
 #Newbie programmer def factorial(x): if x == 0: return 1 else: return x * factorial(x - 1) print factorial(6) #First year programmer, studied Pascal def factorial(x): result = 1 i = 2 while i <= x: result = result * i i = i + 1 return result print factorial(6) #First year programmer, studied C def fact(x): #{ result = i = 1; while (i <= x): #{ result *= i; i += 1; #} return result; #} print(fact(6)) #First year programmer, SICP @tailcall def fact(x, acc=1): if (x > 1): return (fact((x - 1), (acc * x))) else: return acc print(fact(6)) #First year programmer, Python def Factorial(x): res = 1 for i in xrange(2, x + 1): res *= i return res print Factorial(6) #Lazy Python programmer def fact(x): return x > 1 and x * fact(x - 1) or 1 print fact(6) #Lazier Python programmer f = lambda x: x and x * f(x - 1) or 1 print f(6) #Python expert programmer import operator as op import functional as f fact = lambda x: f.foldl(op.mul, 1, xrange(2, x + 1)) print fact(6) #Python hacker import sys @tailcall def fact(x, acc=1): if x: return fact(x.__sub__(1), acc.__mul__(x)) return acc sys.stdout.write(str(fact(6)) + '\n') #EXPERT PROGRAMMER import c_math fact = c_math.fact print fact(6) #ENGLISH EXPERT PROGRAMMER import c_maths fact = c_maths.fact print fact(6) #Web designer def factorial(x): #------------------------------------------------- #--- Code snippet from The Math Vault --- #--- Calculate factorial (C) Arthur Smith 1999 --- #------------------------------------------------- result = str(1) i = 1 #Thanks Adam while i <= x: #result = result * i #It's faster to use *= #result = str(result * result + i) #result = int(result *= i) #?????? result str(int(result) * i) #result = int(str(result) * i) i = i + 1 return result print factorial(6) #Unix programmer import os def fact(x): os.system('factorial ' + str(x)) fact(6) #Windows programmer NULL = None def CalculateAndPrintFactorialEx(dwNumber, hOutputDevice, lpLparam, lpWparam, lpsscSecurity, *dwReserved): if lpsscSecurity != NULL: return NULL #Not implemented dwResult = dwCounter = 1 while dwCounter <= dwNumber: dwResult *= dwCounter dwCounter += 1 hOutputDevice.write(str(dwResult)) hOutputDevice.write('\n') return 1 import sys CalculateAndPrintFactorialEx(6, sys.stdout, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) #Enterprise programmer def new(cls, *args, **kwargs): return cls(*args, **kwargs) class Number(object): pass class IntegralNumber(int, Number): def toInt(self): return new (int, self) class InternalBase(object): def __init__(self, base): self.base = base.toInt() def getBase(self): return new (IntegralNumber, self.base) class MathematicsSystem(object): def __init__(self, ibase): Abstract @classmethod def getInstance(cls, ibase): try: cls.__instance except AttributeError: cls.__instance = new (cls, ibase) return cls.__instance class StandardMathematicsSystem(MathematicsSystem): def __init__(self, ibase): if ibase.getBase() != new (IntegralNumber, 2): raise NotImplementedError self.base = ibase.getBase() def calculateFactorial(self, target): result = new (IntegralNumber, 1) i = new (IntegralNumber, 2) while i <= target: result = result * i i = i + new (IntegralNumber, 1) return result print StandardMathematicsSystem.getInstance(new (InternalBase, new (IntegralNumber, 2))).calculateFactorial(new (IntegralNumber, 6)) 

fonte http://gist.github.com/25049

Usa il seguente codice per farlo.

 #include  #include  int main() { int x, number, fac; fac = 1; printf("Enter a number:\n"); scanf("%d",&number); if(number<0) { printf("Factorial not defined for negative numbers.\n"); exit(0); } for(x = 1; x <= number; x++) { if (number >= 0) fac = fac * x; else fac=1; } printf("%d! = %d\n", number, fac); } 

Per grandi numeri probabilmente è ansible ottenere una soluzione approssimativa, che tgamma ti dà (n! = Gamma (n + 1)) da math.h. Se vuoi numeri ancora più grandi, non si inseriranno in un doppio, quindi dovresti usare lgamma (registro naturale della funzione gamma).

Se lavori da qualche parte senza un C99 math.h completo, puoi fare facilmente questo tipo di cose:

 double logfactorial(int n) { double fac = 0.0; for ( ; n>1 ; n--) fac += log(fac); return fac; } 

Non penso che lo userei nella maggior parte dei casi, ma una pratica ben nota che sta diventando meno diffusa è quella di avere una tabella di ricerca. Se lavoriamo solo con tipi built-in, il colpo di memoria è minuscolo.

Solo un altro approccio, per rendere il poster consapevole di una tecnica diversa. Molte soluzioni ricorsive possono anche essere memoized in cui una tabella di ricerca viene compilata quando l’algoritmo viene eseguito, riducendo drasticamente il costo delle chiamate future (un po ‘come il principio alla base della compilazione .NET JIT immagino).

Esempio in C (C è stato taggato quindi immagino sia quello che vuoi) usando la ricorsione

 unsigned long factorial(unsigned long f) { if (f) return(f * factorial(f - 1)); return 1; } printf("%lu", factorial(5)); 

Dobbiamo iniziare da 1 al limite specificato n Avviare da 1*2*3...*n .

In c, lo sto scrivendo come una funzione.

 main() { int n; scanf("%d",&n); printf("%ld",fact(n)); } long int fact(int n) { long int facto=1; int i; for(i=1;i<=n;i++) { facto=facto*i; } return facto; } 

Più semplice ed efficace è quello di riassumere logarhitms. Se usi Log10 ottieni potenza ed esponente.

pseudocodice

 r=0 for i form 1 to n r=r+log(i)/log(10) print "result is:", 10^(r-floor(r)) ,"*10^" , floor(r) 

Potrebbe essere necessario aggiungere il codice in modo che la parte intera non aumenti troppo e quindi diminuisca la precisione, ma risulterà ok per fattoriali anche molto grandi.

Soluzione semplice:

 unsigned int factorial(unsigned int n) { return (n == 1 || n == 0) ? 1 : factorial(n - 1) * n; } 

Lo farei con una tabella di ricerca precalcasting, come diceva John. Questo sarebbe più veloce da calcolare rispetto a una soluzione iterativa o ricorsiva. Si basa su quanto velocemente n! cresce, perché il più grande n! è ansible calcolare senza straripare un unsigned long long (valore massimo di 18.446.744.073,709,551,615) è solo 20! , quindi hai solo bisogno di un array con 21 elementi. Ecco come apparirebbe in c:

 long long factorial (int n) { long long f[22] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 6227020800, 87178291200, 1307674368000, 20922789888000, 355687428096000, 6402373705728000, 121645100408832000, 2432902008176640000, 51090942171709440000}; return f[n]; } 

Vedi tu stesso!

 **I used this code for Factorial:** #include int main(){ int i=1,f=1,n; printf("\n\nEnter a number: "); scanf("%d",&n); while(i<=n){ f=f*i; i++; } printf("Factorial of is: %d",f); getch(); }