Có phương pháp nào tính giai thừa trong Java không?

Tôi vẫn chưa tìm thấy nó. Tôi đã bỏ lỡ điều gì đó? Tôi biết phương pháp giai thừa là một chương trình ví dụ phổ biến cho người mới bắt đầu. Nhưng sẽ không hữu ích nếu có một triển khai tiêu chuẩn để sử dụng lại cái này? Tôi có thể sử dụng phương pháp như vậy với các kiểu tiêu chuẩn (Ví dụ: int, long ...) và cả với BigInteger / BigDecimal.

Tôi không nghĩ sẽ hữu ích nếu có một hàm thư viện cho giai thừa. Có rất nhiều nghiên cứu về triển khai giai thừa hiệu quả. Đây là một số cách triển khai.

Apache Commons Math có một vài phương thức giai thừa trong lớp MathUtils .

public class UsefulMethods {
    public static long factorial(int number) {
        long result = 1;

        for (int factor = 2; factor <= number; factor++) {
            result *= factor;
        }

        return result;
    }
}

Phiên bản Big Numbers của HoldOffHunger :

public static BigInteger factorial(BigInteger number) {
    BigInteger result = BigInteger.valueOf(1);

    for (long factor = 2; factor <= number.longValue(); factor++) {
        result = result.multiply(BigInteger.valueOf(factor));
    }

    return result;
}

Trong thực tế hiếm khi cần đến các thừa số trần trụi. Thông thường, bạn sẽ cần một trong những thứ sau:

1) chia một giai thừa này cho một giai thừa khác, hoặc

2) câu trả lời gần đúng dấu phẩy động.

Trong cả hai trường hợp, bạn sẽ tốt hơn với các giải pháp tùy chỉnh đơn giản.

Trong trường hợp (1), giả sử, nếu x = 90! / 85 !, sau đó bạn sẽ tính được kết quả là x = 86 * 87 * 88 * 89 * 90 mà không cần phải giữ 90! trong trí nhớ :)

Trong trường hợp (2), hãy google để tìm "Ước lượng của Stirling".

Sử dụng Ổi BigIntegerMathnhư sau:

BigInteger factorial = BigIntegerMath.factorial(n);

(Chức năng tương tự cho intvà longcó sẵn trong IntMathvà LongMathtương ứng.)

Mặc dù giai thừa thực sự là một bài tập tốt cho lập trình viên mới bắt đầu, nhưng chúng không hữu ích lắm trong hầu hết các trường hợp và mọi người đều biết cách viết một hàm giai thừa, vì vậy chúng thường không có trong thư viện trung bình.

tôi tin rằng đây sẽ là cách nhanh nhất, bằng một bảng tra cứu:

private static final long[] FACTORIAL_TABLE = initFactorialTable();
private static long[] initFactorialTable() {
    final long[] factorialTable = new long[21];
    factorialTable[0] = 1;
    for (int i=1; i<factorialTable.length; i++)
        factorialTable[i] = factorialTable[i-1] * i;
    return factorialTable;
}
/**
 * Actually, even for {@code long}, it works only until 20 inclusively.
 */
public static long factorial(final int n) {
    if ((n < 0) || (n > 20))
        throw new OutOfRangeException("n", 0, 20);
    return FACTORIAL_TABLE[n];
}

Đối với kiểu gốc long(8 byte), nó chỉ có thể chứa tối đa20!

20! = 2432902008176640000(10) = 0x 21C3 677C 82B4 0000

Chắc chắn, 21! sẽ gây tràn.

Do đó, đối với kiểu gốc long, chỉ tối đa 20!là được phép, có nghĩa và chính xác.

Vì giai thừa phát triển rất nhanh, nên việc tràn ngăn xếp không phải là vấn đề nếu bạn sử dụng đệ quy. Trên thực tế, giá trị của 20! là cái lớn nhất có thể đại diện trong một Java dài. Vì vậy, phương thức sau đây sẽ tính giai thừa (n) hoặc ném IllegalArgumentException nếu n quá lớn.

public long factorial(int n) {
    if (n > 20) throw new IllegalArgumentException(n + " is out of range");
    return (1 > n) ? 1 : n * factorial(n - 1);
}

Một cách khác (hay hơn) để làm điều tương tự là sử dụng thư viện luồng của Java 8 như sau:

public long factorial(int n) {
    if (n > 20) throw new IllegalArgumentException(n + " is out of range");        
    return LongStream.rangeClosed(1, n).reduce(1, (a, b) -> a * b);
}

Đọc thêm về Factorials sử dụng các luồng của Java 8

Gói Apache Commons Math có một phương pháp giai thừa , tôi nghĩ bạn có thể sử dụng nó.

Câu trả lời ngắn gọn là: sử dụng đệ quy.

Bạn có thể tạo một phương thức và gọi phương thức đó ngay trong cùng một phương thức một cách đệ quy:

public class factorial {

    public static void main(String[] args) {
        System.out.println(calc(10));
    }

    public static long calc(long n) {
        if (n <= 1)
            return 1;
        else
            return n * calc(n - 1);
    }
}

Thử cái này

public static BigInteger factorial(int value){
    if(value < 0){
        throw new IllegalArgumentException("Value must be positive");
    }

    BigInteger result = BigInteger.ONE;
    for (int i = 2; i <= value; i++) {
        result = result.multiply(BigInteger.valueOf(i));
    }

    return result;
}

Tôi đã tìm thấy một thủ thuật tuyệt vời để tìm thừa số chỉ bằng một nửa số phép nhân thực tế.

Hãy kiên nhẫn vì đây là một bài viết hơi dài.

Đối với số chẵn: Để giảm một nửa phép nhân với số chẵn, bạn sẽ có n / 2 thừa số. Thừa số đầu tiên sẽ là số bạn đang lấy giai thừa, sau đó thừa số tiếp theo sẽ là số đó cộng với số đó trừ đi hai. Số tiếp theo sẽ là số trước đó cộng với số được cộng cuối cùng trừ đi hai. Bạn đã hoàn tất khi số cuối cùng bạn thêm vào là hai (tức là 2) . Điều đó có lẽ không có nhiều ý nghĩa, vì vậy hãy để tôi cho bạn một ví dụ.

8! = 8 * (8 + 6 = 14) * (14 + 4 = 18) * (18 + 2 = 20)

8! = 8 * 14 * 18 * 20 which is **40320** 

Lưu ý rằng tôi bắt đầu với 8, sau đó số đầu tiên tôi thêm vào là 6, sau đó 4, sau đó là 2, mỗi số thêm vào là hai ít hơn sau đó số thêm vào trước nó. Phương pháp này tương đương với việc nhân số ít nhất với số lớn nhất, chỉ với phép nhân ít hơn, như sau:

8! = 1 * 2 * 3 * 4 * 5 * 6 * 7 * 
8! = (1 * 8) * (2 * 7) * (3 * 6) * (4 * 5)
8! = 8 * 14 * 18 * 20

Đơn giản phải không :)

Now For Odd Numbers: Nếu là số lẻ, phép cộng cũng giống như khi bạn trừ hai lần mỗi lần, nhưng bạn dừng lại ở ba. Tuy nhiên, số lượng các yếu tố thay đổi. Nếu bạn chia số cho hai, bạn sẽ có một số kết thúc bằng .5. Lý do là nếu chúng ta nhân các đầu với nhau, chúng ta sẽ còn lại với số ở giữa. Về cơ bản, điều này đều có thể được giải quyết bằng cách giải cho một số thừa số bằng số bị chia cho hai, làm tròn. Điều này có lẽ cũng không có ý nghĩa gì đối với những người không có nền tảng toán học, vì vậy hãy để tôi làm một ví dụ:

9! = 9 * (9 + 7 = 16) * (16 + 5 = 21) * (21 + 3 = 24) * (roundUp(9/2) = 5)

9! = 9 * 16 * 21 * 24 * 5 = **362880**

Lưu ý: Nếu bạn không thích phương pháp này, bạn cũng có thể lấy giai thừa của số chẵn trước số lẻ (trong trường hợp này là tám) và nhân nó với số lẻ (tức là 9! = 8! * 9).

Bây giờ hãy triển khai nó trong Java:

public static int getFactorial(int num)
{
    int factorial=1;
    int diffrennceFromActualNum=0;
    int previousSum=num;

    if(num==0) //Returning  1 as factorial if number is 0 
        return 1;
    if(num%2==0)//  Checking if Number is odd or even
    { 
        while(num-diffrennceFromActualNum>=2)
        {
            if(!isFirst)
            {
                previousSum=previousSum+(num-diffrennceFromActualNum);  
            }
            isFirst=false;
            factorial*=previousSum;
            diffrennceFromActualNum+=2;
        }
    }
    else // In Odd Case (Number * getFactorial(Number-1))
    {
        factorial=num*getFactorial(num-1);
    }
    return factorial;
}

isFirstlà một biến boolean được khai báo là static; nó được sử dụng cho trường hợp đầu tiên mà chúng ta không muốn thay đổi tổng trước đó.

Thử với số chẵn cũng như số lẻ.

Bạn có thể sử dụng đệ quy.

public static int factorial(int n){    
      if (n == 0)    
        return 1;    
      else    
        return(n * factorial(n-1));    
     }

và sau đó sau khi bạn tạo phương thức (hàm) ở trên:

System.out.println(factorial(number of your choice));  
    //direct example
    System.out.println(factorial(3));

Cách sử dụng kinh doanh duy nhất cho giai thừa mà tôi có thể nghĩ đến là công thức Erlang B và Erlang C, và không phải ai cũng làm việc trong trung tâm cuộc gọi hoặc công ty điện thoại. Tính hữu ích của một tính năng đối với doanh nghiệp dường như thường ra lệnh cho những gì hiển thị bằng một ngôn ngữ - hãy xem tất cả các chức năng xử lý dữ liệu, XML và web bằng các ngôn ngữ chính.

Thật dễ dàng để giữ một đoạn mã giai thừa hoặc hàm thư viện cho những thứ như thế này.

Một phương pháp rất đơn giản để tính thừa số:

private double FACT(double n) {
    double num = n;
    double total = 1;
    if(num != 0 | num != 1){
        total = num;
    }else if(num == 1 | num == 0){
        total = 1;
    }
    double num2;
    while(num > 1){
        num2 = num - 1;
        total = total * num2;
        num = num - 1;
    }
    return total;
}

Tôi đã sử dụng double vì chúng có thể chứa số lượng lớn, nhưng bạn có thể sử dụng bất kỳ loại nào khác như int, long, float, v.v.

Tái bút Đây có thể không phải là giải pháp tốt nhất nhưng tôi mới làm quen với lập trình và tôi đã mất nhiều thời gian để tìm một mã đơn giản có thể tính toán giai thừa vì vậy tôi phải tự viết phương pháp nhưng tôi đang đặt nó ở đây để nó giúp những người khác như tôi .

Bạn cũng có thể sử dụng phiên bản đệ quy.

static int myFactorial(int i) {
    if(i == 1)
        return;
    else
        System.out.prinln(i * (myFactorial(--i)));
}

Đệ quy thường kém hiệu quả hơn vì phải đẩy và bật các đệ quy, vì vậy việc lặp lại nhanh hơn. Mặt khác, các phiên bản đệ quy sử dụng ít hơn hoặc không có biến cục bộ, đó là lợi thế.

Giai thừa là một chức năng rời rạc ngày càng tăng cao, vì vậy tôi nghĩ rằng sử dụng BigInteger tốt hơn là sử dụng int. Tôi đã triển khai mã sau đây để tính giai thừa của các số nguyên không âm. Tôi đã sử dụng đệ quy thay vì sử dụng một vòng lặp.

public  BigInteger factorial(BigInteger x){     
    if(x.compareTo(new BigInteger("1"))==0||x.compareTo(new BigInteger("0"))==0)
        return new BigInteger("1");
    else return x.multiply(factorial(x.subtract(new BigInteger("1")))); 
}

Ở đây phạm vi của số nguyên lớn là

-2^Integer.MAX_VALUE (exclusive) to +2^Integer.MAX_VALUE,
where Integer.MAX_VALUE=2^31.

Tuy nhiên, phạm vi của phương pháp giai thừa được đưa ra ở trên có thể được mở rộng lên đến hai lần bằng cách sử dụng BigInteger không dấu.

Chúng tôi có một dòng duy nhất để tính toán nó:

Long factorialNumber = LongStream.rangeClosed(2, N).reduce(1, Math::multiplyExact);

Một phương pháp khá đơn giản

    for ( int i = 1; i < n ; i++ )
    {
            answer = answer * i;
    }

    /**
import java liberary class

*/
import java.util.Scanner;

/* class to find factorial of a number
*/

public class factorial
{
public static void main(String[] args)
{

// scanner method for read keayboard values

    Scanner factor= new Scanner(System.in);

    int n;
    double total = 1;
    double sum= 1;

    System.out.println("\nPlease enter an integer: ");
    n = factor.nextInt();

// evaluvate the integer is greater than zero and calculate factorial

if(n==0)

{
    System.out.println(" Factorial of 0 is 1");
}
else if (n>0)
{
    System.out.println("\nThe factorial of " + n + " is " );

    System.out.print(n);

    for(int i=1;i<n;i++)
    {
        do // do while loop for display each integer in the factorial
              {
                System.out.print("*"+(n-i) );
              }

        while ( n == 1);

      total = total * i;

    }

// calculate factorial
sum= total * n;


// display sum of factorial

    System.out.println("\n\nThe "+ n +" Factorial is : "+" "+ sum);
}

// display invalid entry, if enter a value less than zero

else

{
    System.out.println("\nInvalid entry!!");

}System.exit(0);
}
}

public static int fact(int i){
    if(i==0)
       return 0;
    if(i>1){
       i = i * fact(--i);
    }

   return i;
}

Chúng ta cần triển khai lặp đi lặp lại. Nếu chúng ta triển khai đệ quy, nó sẽ gây ra StackOverflow nếu đầu vào trở nên rất lớn (tức là 2 tỷ). Và chúng ta cần sử dụng số kích thước không bị ràng buộc như BigInteger để tránh tràn số học khi một số giai thừa trở nên lớn hơn số tối đa của một kiểu nhất định (tức là 2 tỷ đối với int). Bạn có thể sử dụng int cho tối đa 14 giai thừa và long cho tối đa 20 giai thừa trước khi tràn.

public BigInteger getFactorialIteratively(BigInteger input) {
    if (input.compareTo(BigInteger.ZERO) <= 0) {
        throw new IllegalArgumentException("zero or negatives are not allowed");
    }

    BigInteger result = BigInteger.ONE;
    for (BigInteger i = BigInteger.ONE; i.compareTo(input) <= 0; i = i.add(BigInteger.ONE)) {
        result = result.multiply(i);
    }
    return result;
}

Nếu bạn không thể sử dụng BigInteger, hãy thêm kiểm tra lỗi.

public long getFactorialIteratively(long input) {
    if (input <= 0) {
        throw new IllegalArgumentException("zero or negatives are not allowed");
    } else if (input == 1) {
        return 1;
    }

    long prev = 1;
    long result = 0;
    for (long i = 2; i <= input; i++) {
        result = prev * i;
        if (result / prev != i) { // check if result holds the definition of factorial
            // arithmatic overflow, error out
            throw new RuntimeException("value "+i+" is too big to calculate a factorial, prev:"+prev+", current:"+result);
        }
        prev = result;
    }
    return result;
}

public int factorial(int num) {
        if (num == 1) return 1;
        return num * factorial(num - 1);
}

vòng lặp while (dành cho số lượng nhỏ)

public class factorial {

public static void main(String[] args) {
    int counter=1, sum=1;

    while (counter<=10) {
        sum=sum*counter;
        counter++;
   }

    System.out.println("Factorial of 10 is " +sum);
   }
}

Tôi nhận được cái này từ EDX sử dụng nó! nó được gọi là đệ quy

   public static int factorial(int n) {
    if (n == 1) {
        return 1;
    } else {
        return n * factorial(n-1);
    }
}

với đệ quy:

public static int factorial(int n)
{
    if(n == 1)
    {
        return 1;
    }               
    return n * factorial(n-1);
}

với vòng lặp while:

public static int factorial1(int n)
{
    int fact=1;
    while(n>=1)
    {
        fact=fact*n;
        n--;
    }
    return fact;
}

SỬ DỤNG LẬP TRÌNH ĐỘNG LÀ HIỆU QUẢ

nếu bạn muốn sử dụng nó để tính toán nhiều lần (như bộ nhớ đệm)

Mã Java:

int fact[]=new int[n+1]; //n is the required number you want to find factorial for.
int factorial(int num)
 {
    if(num==0){
     fact[num]=1;
     return fact[num];
       }
     else
       fact[num]=(num)*factorial(num-1);

     return fact[num];
 }

sử dụng đệ quy là phương pháp đơn giản nhất. nếu chúng ta muốn tìm giai thừa của N, chúng ta phải xét hai trường hợp N = 1 và N> 1 vì trong giai thừa chúng ta cứ nhân N, N-1, N-2 ,,,,, cho đến 1 nếu chúng ta chuyển đến N = 0, chúng ta sẽ nhận được 0 cho câu trả lời. Để ngăn giai thừa bằng không, phương pháp đệ quy sau được sử dụng. Bên trong hàm giai thừa, khi N> 1, giá trị trả về được nhân với một lần khởi tạo khác của hàm giai thừa. điều này sẽ giữ cho mã gọi một cách đệ quy giai thừa () cho đến khi nó đạt đến giá trị N = 1. Đối với trường hợp N = 1, nó trả về chính N (= 1) và tất cả kết quả đã xây dựng trước đó của trả về nhân N sẽ được nhân với N = 1. Do đó cho kết quả giai thừa.

static int factorial(int N) {
    if(N > 1) { 
    return n * factorial(N - 1);
    }
    // Base Case N = 1
    else { 
    return N;
    }