2 Write a program in java to find factorial of a number?

Answer 1

import java.math.BigInteger;

public class Factorial {

public static void main(String[] args) {

BigInteger n = BigInteger.ONE;

for (int i=1; i<=20; i++) {

n = n.multiply(BigInteger.valueOf(i));

System.out.println(i + "! = " + n);

}

Answer 2

import java.io.*;

class Factorial_For{

public static void main(String[] args) {

try{

BufferedReader object = new BufferedReader(new InputStreamReader(System.in));

System.out.println("enter the number");

int a= Integer.parseInt(object.readLine());

int fact= 1;

System.out.println("Factorial of " +a+ ":");

for (int i= 1; i<=a; i++){

fact=fact*i;

}

System.out.println(fact);

}

catch (Exception e){}

}

}

Answer 3

Recursion is not the most efficient in this case; but this serves to demostrate the basic principles of recursion. Recursion is really useful in some other cases; it can make problems that otherwise look impossible, to actually seem easy, once you grasp the basic ideas of recursion. 5! (5 factorial), for example, is 1 x 2 x 3 x 4 x 5. This can also be defined as 5 x 4! (5 times 4 factorial). For a useful recursion, there must be an ending condition; in this case, 0! is defined as 1. The Java function looks something like this: int factorial(int number) { if (number == 0) return 1; else return number * factorial(number - 1); } The following is a shorter, but equivalent, version that uses the ternary operator: int factorial(int number) { return number == 0 ? 1 : number * factorial(number - 1); }

Recursion is not the most efficient in this case; but this serves to demostrate the basic principles of recursion. Recursion is really useful in some other cases; it can make problems that otherwise look impossible, to actually seem easy, once you grasp the basic ideas of recursion. 5! (5 factorial), for example, is 1 x 2 x 3 x 4 x 5. This can also be defined as 5 x 4! (5 times 4 factorial). For a useful recursion, there must be an ending condition; in this case, 0! is defined as 1. The Java function looks something like this: int factorial(int number) { if (number == 0) return 1; else return number * factorial(number - 1); } The following is a shorter, but equivalent, version that uses the ternary operator: int factorial(int number) { return number == 0 ? 1 : number * factorial(number - 1); }

Recursion is not the most efficient in this case; but this serves to demostrate the basic principles of recursion. Recursion is really useful in some other cases; it can make problems that otherwise look impossible, to actually seem easy, once you grasp the basic ideas of recursion. 5! (5 factorial), for example, is 1 x 2 x 3 x 4 x 5. This can also be defined as 5 x 4! (5 times 4 factorial). For a useful recursion, there must be an ending condition; in this case, 0! is defined as 1. The Java function looks something like this: int factorial(int number) { if (number == 0) return 1; else return number * factorial(number - 1); } The following is a shorter, but equivalent, version that uses the ternary operator: int factorial(int number) { return number == 0 ? 1 : number * factorial(number - 1); }

Recursion is not the most efficient in this case; but this serves to demostrate the basic principles of recursion. Recursion is really useful in some other cases; it can make problems that otherwise look impossible, to actually seem easy, once you grasp the basic ideas of recursion. 5! (5 factorial), for example, is 1 x 2 x 3 x 4 x 5. This can also be defined as 5 x 4! (5 times 4 factorial). For a useful recursion, there must be an ending condition; in this case, 0! is defined as 1. The Java function looks something like this: int factorial(int number) { if (number == 0) return 1; else return number * factorial(number - 1); } The following is a shorter, but equivalent, version that uses the ternary operator: int factorial(int number) { return number == 0 ? 1 : number * factorial(number - 1); }

Answer 4

Recursion is not the most efficient in this case; but this serves to demostrate the basic principles of recursion. Recursion is really useful in some other cases; it can make problems that otherwise look impossible, to actually seem easy, once you grasp the basic ideas of recursion. 5! (5 factorial), for example, is 1 x 2 x 3 x 4 x 5. This can also be defined as 5 x 4! (5 times 4 factorial). For a useful recursion, there must be an ending condition; in this case, 0! is defined as 1. The Java function looks something like this: int factorial(int number) { if (number == 0) return 1; else return number * factorial(number - 1); } The following is a shorter, but equivalent, version that uses the ternary operator: int factorial(int number) { return number == 0 ? 1 : number * factorial(number - 1); }

Answer 5

teri maa ka booshda