Program Java untuk faktorial

Hari ini kita akan berbicara tentang faktorial dan cara paling umum untuk menemukan faktorial. Ini adalah salah satu fungsi paling dasar yang perlu diketahui dan dapat dikerjakan oleh seorang programmer. Baiklah, mari kita mulai. Faktorial bilangan n, dilambangkan dengan n!, adalah nilai perkalian (perkalian) semua bilangan asli dari 1 sampai n. Berikut ini tampilannya (mari segarkan kembali pengetahuan Anda tentang matematika): Dan ada satu lagi aturan kecil untuk 0: Jika kita ingin menghitung selisih antara 6! dan 4!: Mari kita lihat seperti apa ini saat diimplementasikan dalam pemrograman. Kami akan mengeksplorasi beberapa cara bagaimana melakukan perhitungan faktorial di Jawa.

Solusi biasa dalam program faktorial

Berikut adalah program faktorial sederhana menggunakan loop:

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);    
 }  
}

Keluaran kami di konsol adalah: Dan satu contoh lagi 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;
}

Tidak ada yang sulit di sini: kami menggunakan angka yang diteruskan sebagai ukuran loop kami, di mana kami mengalikan dengan semua angka sebelumnya hingga kami mendapatkan f. Dan yang utama:

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

Menguji kode, kami melihat bahwa kami mendapatkan hasil yang diinginkan: 696.

Solusi rekursif

Rekursi terjadi ketika suatu metode memanggil dirinya sendiri. Metode seperti ini disebut metode rekursif. Sebagai aturan, itu terdiri dari dua bagian:

1. Kondisi terminasi — ketika kondisi terminasi terpenuhi, metode harus berhenti memanggil dirinya sendiri dan mulai meneruskan nilai ke atas. Lagi pula, jika tidak ada kondisi terminating, maka kita akan memiliki loop tak terbatas, dengan metode yang memanggil dirinya berulang kali hingga kita mendapatkan StackOverflowError .
2. Logika apa pun yang dibutuhkan situasi ditambah panggilan rekursif, tetapi dengan nilai input yang berbeda.

Menemukan faktorial di Jawa adalah contoh sempurna kapan 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);
  }
}

Kondisi penghentian rekursi kami adalah ketika kami mencapai 1. Jika parameternya bukan 1, maka kami mengalikan nilai saat ini dengan hasil panggilan rekursif berikutnya ke metode (di mana kami meneruskan nilai saat ini dikurangi 1).

Solusi dengan Stream

Siapa pun yang tidak terbiasa dengan fungsionalitas Stream Java, atau siapa pun yang ingin menyegarkan ingatannya, akan mendapat manfaat dari membaca 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 khusus , yang memberi kami kemampuan tambahan saat bekerja dengan aliran nilai int. Untuk membuat aliran seperti itu, kami menggunakan metode static rangeClosed , yang menghasilkan nilai dari 2 hingga f, termasuk, dengan kelipatan 1. Selanjutnya, kami menggunakan metode pengurangan untuk menggabungkan semua nilai. Lebih khusus lagi, kami menunjukkan bagaimana kami ingin menggabungkan nilai. Terakhir, kami mendapatkan nilai yang dihasilkan menggunakan metode terminal getAsInt .

Menggunakan BigInteger

Di Java, kelas BigInteger sering digunakan untuk menangani bilangan, khususnya bilangan BESAR. Memang, jika kita menggunakan int , maka faktorial maksimum yang dapat kita tangani tanpa kehilangan data adalah 31. Untuk tipe data yang panjang , faktorial maksimum adalah 39. Tetapi bagaimana jika kita membutuhkan faktorial 100? Mari mengadaptasi solusi sebelumnya ke BigInteger.

Solusi 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;
}

Algoritme pada dasarnya sama, tetapi di sini kami menggunakan kemampuan BigInteger: BigInteger.ONE adalah nilai awal 1, dan multiply() digunakan untuk mengalikan nilai faktorial sebelumnya dan angka saat ini.

Solusi rekursif

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

Logika umum solusi tidak berubah, kecuali beberapa metode ditambahkan untuk bekerja dengan BigInteger.

Solusi dengan Stream

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 dasarnya sama, tetapi dengan BigInteger. Kelas Stream memberi kita metode mapToObj , yang kita gunakan untuk mengonversi nilai int menjadi BigInteger untuk kemudian mengalikannya dengan diri mereka sendiri menggunakan metode perkalian (dan get() ditambahkan untuk mendapatkan objek dari pembungkus Opsional ). Jika kita menjalankan salah satu dari ketiga metode ini dengan argumen 100, maka kita akan menghindari stack overflow dan mendapatkan hasil yang benar: