Faktöriyel için Java Programı

Bugün faktöriyellerden ve faktöriyel bulmanın en yaygın yollarından bahsedeceğiz. Bu, bir programcının hem bilmesi hem de birlikte çalışabilmesi için ihtiyaç duyduğu en temel işlevlerden biridir. Pekala, başlayalım. n! ile gösterilen n sayısının faktöriyeli, 1'den n'ye kadar olan tüm doğal sayıların çarpımının (çarpım) değeridir. İşte göründüğü gibi (matematik bilginizi tazeleyelim): Ve 0 için küçük bir kural daha var: 6 arasındaki farkı hesaplamak istersek! ve 4!: Programlamada uygulandığında bunun nasıl görüneceğini görelim. Java'da faktöriyel hesaplamalarının nasıl yapılacağına dair birkaç yol keşfedeceğiz.

Faktöriyel programında sıradan çözüm

İşte döngü kullanan basit bir faktöriyel programı:

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

Konsoldaki çıktımız şöyle olacaktır: Ve işleri sıralamak için bir örnek daha:

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

Burada zor bir şey yok: geçen sayıyı, f'ye ulaşana kadar önceki tüm sayılarla çarptığımız döngümüzün boyutu olarak kullanıyoruz. Ve ana olarak:

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

Kodu test ederek istenen sonucu aldığımızı görüyoruz: 696.

özyinelemeli çözüm

Özyineleme, bir yöntem kendisini çağırdığında gerçekleşir. Böyle bir yönteme özyinelemeli yöntem denir. Kural olarak, iki bölümden oluşur:

1. Bir sonlandırma koşulu — sonlandırma koşulu karşılandığında, yöntem kendisini çağırmayı bırakmalı ve değerleri yukarı aktarmaya başlamalıdır. Sonuçta, sonlandırma koşulu yoksa, bir StackOverflowError elde edene kadar yöntemin kendisini tekrar tekrar çağırdığı sonsuz bir döngüye sahip olacağız .
2. Durumun gerektirdiği mantık ne olursa olsun artı yinelemeli bir çağrı, ancak farklı bir giriş değeriyle.

Java'da faktöriyel bulmak, özyinelemenin ne zaman kullanılacağına dair mükemmel bir örnektir:

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

1'e ulaştığımızda özyineleme sonlandırma koşulumuz olacaktır. Parametre 1 değilse, o zaman yönteme bir sonraki özyinelemeli çağrının sonucuyla (mevcut değer eksi 1'i geçirdiğimiz) mevcut değeri çarparız.

Akış ile Çözüm

Java'nın Akış işlevine aşina olmayan veya hafızasını tazelemek isteyen herkes burayı okumaktan faydalanacaktır .

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

Burada , bir int değerleri akışıyla çalışırken bize ek yetenekler sağlayan özel IntStream sınıfını kullanıyoruz . Böyle bir akış oluşturmak için, 2'den f'ye (dahil) 1'lik artışlarla değer üreten statik rangeClosed yöntemini kullanırız . Ardından, tüm değerleri birleştirmek için reduce yöntemini kullanırız. Daha spesifik olarak, ona değerleri nasıl birleştirmek istediğimizi gösteriyoruz. Son olarak, terminal getAsInt yöntemini kullanarak elde edilen değeri elde ederiz.

BigInteger'ı kullanma

Java'da, BigInteger sınıfı genellikle sayıları, özellikle BÜYÜK sayıları işlemek için kullanılır. Aslında, int kullanırsak , veri kaybı olmadan kaldırabileceğimiz maksimum faktöriyel 31'dir. Uzun veri tipi için maksimum faktöriyel 39'dur. Peki ya 100 faktöriyeline ihtiyacımız varsa? Önceki çözümleri BigInteger'a uyarlayalım.

Sıradan çözüm

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 temelde aynıdır, ancak burada BigInteger'ın yeteneklerini kullanıyoruz: BigInteger.ONE başlangıç ​​değeri 1'dir ve multiple() önceki faktöriyel değeri ile mevcut sayıyı çarpmak için kullanılır.

özyinelemeli çözüm

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

BigInteger ile çalışmak için bazı metotlar eklenmesi dışında çözümün genel mantığı değişmiyor.

Akış ile Çözüm

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

Her şey aslında aynı, ancak BigInteger ile. Stream sınıfı bize , int değerlerini BigInteger'a dönüştürmek ve daha sonra bunları çarpma yöntemini kullanarak kendileriyle çarpmak için kullandığımız mapToObj yöntemini verir (ve İsteğe bağlı sarmalayıcıdan bir nesne almak için get() eklenmiştir ). Bu üç yöntemden herhangi birini 100 argümanıyla çalıştırırsak, yığın taşmasını önler ve doğru sonucu alırız: