Program Java untuk faktorial

Hari ini kita akan bercakap tentang faktorial dan cara yang paling biasa untuk mencari faktorial. Ini adalah salah satu fungsi paling asas yang seorang pengaturcara perlu tahu dan boleh bekerja dengannya. Baiklah, mari kita mulakan. Faktorial bagi nombor n, dilambangkan sebagai n!, ialah nilai hasil darab semua nombor asli dari 1 hingga n. Begini rupanya (mari segarkan pengetahuan anda tentang matematik): Dan terdapat satu lagi peraturan kecil untuk 0: Jika kita ingin mengira perbezaan antara 6! dan 4!: Mari lihat bagaimana ini akan kelihatan apabila dilaksanakan dalam pengaturcaraan. Kami akan meneroka beberapa cara untuk melakukan pengiraan faktorial di Jawa.

Penyelesaian biasa dalam program faktorial

Berikut ialah program faktorial mudah menggunakan gelung:

class FactorialExample{  
 public static void main(String args[]){  
  int i,fact=1;  
  int number=7;// our number to do the necessary calculations in class Factorial    
  for(i=1;i<=number;i++){    
      fact=fact*i;    
  }    
  System.out.println("Factorial of "+number+" is: "+fact);    
 }  
}

Output kami pada konsol ialah: Dan satu lagi contoh untuk menyelesaikan masalah:

public static int getFactorial(int f) {
  int result = 1;
  for (int i = 1; i <= f; i++) {
     result = result * i; // finding factorial of number using loops
  }
  return result;
}

Tiada apa-apa yang sukar di sini: kami menggunakan nombor yang diluluskan sebagai saiz gelung kami, di mana kami mendarab dengan semua nombor sebelumnya sehingga kami sampai ke f. Dan secara utama:

System.out.println(getFactorial(6) - getFactorial(4));

Menguji kod, kami melihat bahawa kami mendapat hasil yang diingini: 696.

Penyelesaian rekursif

Rekursi berlaku apabila kaedah memanggil dirinya sendiri. Kaedah sedemikian dipanggil kaedah rekursif. Sebagai peraturan, ia terdiri daripada dua bahagian:

1. Keadaan penamatan — apabila syarat penamatan dipenuhi, kaedah harus berhenti memanggil dirinya sendiri dan mula menghantar nilai. Lagipun, jika tiada syarat penamatan, maka kita akan mempunyai gelung tak terhingga, dengan kaedah memanggil dirinya berulang kali sehingga kita mendapat StackOverflowError .
2. Walau apa pun logik yang diperlukan oleh keadaan ditambah dengan panggilan rekursif, tetapi dengan nilai input yang berbeza.

Mencari faktorial dalam Java ialah contoh sempurna apabila menggunakan rekursi:

public static int getFactorial(int f) { // finding factorial of number using recursive solution
  if (f <= 1) {
     return 1;
  }
  else {
     return f * getFactorial(f - 1);
  }
}

Keadaan penamatan rekursi kami ialah apabila kami mencapai 1. Jika parameter bukan 1, maka kami mendarabkan nilai semasa dengan hasil panggilan rekursif seterusnya kepada kaedah (yang mana kami lulus nilai semasa tolak 1).

Penyelesaian dengan Strim

Sesiapa sahaja yang tidak biasa dengan fungsi Stream Java, atau sesiapa sahaja yang ingin menyegarkan ingatan mereka, akan mendapat manfaat daripada membaca tentang di sini .

public static int getFactorial(int f) { // finding factorial of number using Stream 
  if (f <= 1) {
     return 1;
  }
  else {
     return IntStream.rangeClosed(2, f).reduce((x, y) -> x * y).getAsInt();
  }
}

Di sini kami menggunakan kelas IntStream khas , yang memberikan kami keupayaan tambahan apabila bekerja dengan aliran nilai int. Untuk mencipta strim sedemikian, kami menggunakan kaedah Tertutup julat statiknya , yang menjana nilai dari 2 hingga f, inklusif, dalam kenaikan 1. Seterusnya, kami menggunakan kaedah pengurangan untuk menggabungkan semua nilai. Lebih khusus lagi, kami menunjukkan cara kami ingin menggabungkan nilai. Akhirnya, kami mendapat nilai yang terhasil menggunakan kaedah getAsInt terminal .

Menggunakan BigInteger

Di Java, kelas BigInteger sering digunakan untuk mengendalikan nombor, terutamanya nombor BIG. Sesungguhnya, jika kita menggunakan int , maka faktorial maksimum yang boleh kita kendalikan tanpa kehilangan data ialah 31. Untuk jenis data yang panjang , faktorial maksimum ialah 39. Tetapi bagaimana jika kita memerlukan faktorial 100? Mari kita sesuaikan penyelesaian sebelumnya kepada BigInteger.

Penyelesaian biasa

public static BigInteger getFactorial(int f) { // finding factorial of number using BigInteger
  BigInteger result = BigInteger.ONE;
  for (int i = 1; i <= f; i++)
     result = result.multiply(BigInteger.valueOf(i));
  return result;
}

Algoritma pada asasnya adalah sama, tetapi di sini kami menggunakan keupayaan BigInteger: BigInteger.ONE ialah nilai permulaan 1, dan darab() digunakan untuk mendarab nilai faktor sebelumnya dan nombor semasa.

Penyelesaian rekursif

public static BigInteger getFactorial(int f) {
  if (f <= 1) {
     return BigInteger.valueOf(1);
  }
  else {
     return BigInteger.valueOf(f).multiply(getFactorial(f - 1));
  }
}

Logik umum penyelesaian tidak berubah, kecuali beberapa kaedah ditambah untuk bekerja dengan BigInteger.

Penyelesaian dengan Strim

public static BigInteger getFactorial(int f) {
  if (f < 2) {
     return BigInteger.valueOf(1);
  }
  else {
     return IntStream.rangeClosed(2, f).mapToObj(BigInteger::valueOf).reduce(BigInteger::multiply).get();
  }
}

Semuanya pada asasnya sama, tetapi dengan BigInteger. Kelas Stream memberi kami kaedah mapToObj , yang kami gunakan untuk menukar nilai int kepada BigInteger untuk kemudian mendarabkannya dengan diri mereka sendiri menggunakan kaedah darab (dan get() telah ditambahkan untuk mendapatkan objek daripada pembalut Pilihan ). Jika kita menjalankan mana-mana daripada tiga kaedah ini dengan hujah 100, maka kita akan mengelakkan limpahan tindanan dan mendapatkan hasil yang betul: