Java Program para sa factorial

Ngayon ay pag-uusapan natin ang tungkol sa mga factorial at ang pinakakaraniwang paraan upang makahanap ng factorial. Ito ay isa sa mga pinaka-pangunahing function na kailangang malaman ng isang programmer at magagawang gamitin. Well, simulan na natin. Ang factorial ng bilang n, na tinutukoy bilang n!, ay ang halaga ng produkto (multiplikasyon) ng lahat ng natural na numero mula 1 hanggang n. Narito kung ano ang hitsura nito (i-refresh natin ang iyong kaalaman sa matematika): At may isa pang maliit na panuntunan para sa 0: Kung gusto nating kalkulahin ang pagkakaiba sa pagitan ng 6! at 4!: Tingnan natin kung ano ang magiging hitsura nito kapag ipinatupad sa programming. Mag-e-explore kami ng ilang paraan kung paano gumawa ng mga kalkulasyon ng factorial sa Java.

Ordinaryong solusyon sa factorial program

Narito ang isang simpleng factorial program gamit ang 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);    
 }  
}

Ang aming output sa console ay: At isa pang halimbawa upang ayusin ang mga bagay:

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

Walang mahirap dito: ginagamit namin ang naipasa na numero bilang laki ng aming loop, kung saan i-multiply namin sa lahat ng naunang numero hanggang sa makarating kami sa f. At sa pangunahing:

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

Pagsubok sa code, nakita namin na nakukuha namin ang ninanais na resulta: 696.

Recursive na solusyon

Nangyayari ang recursion kapag tinawag ng isang pamamaraan ang sarili nito. Ang ganitong paraan ay tinatawag na recursive method. Bilang isang patakaran, ito ay binubuo ng dalawang bahagi:

1. Isang kundisyon sa pagwawakas — kapag nasiyahan ang kundisyon ng pagwawakas, dapat ihinto ng pamamaraan ang pagtawag sa sarili nito at simulan ang pagpapasa ng mga halaga. Pagkatapos ng lahat, kung walang kondisyon sa pagtatapos, magkakaroon tayo ng walang katapusang loop, na paulit-ulit na tinatawag ang pamamaraan hanggang sa makakuha tayo ng StackOverflowError .
2. Anuman ang lohika na kailangan ng sitwasyon kasama ang isang recursive na tawag, ngunit may ibang halaga ng input.

Ang paghahanap ng factorial sa Java ay isang perpektong halimbawa kung kailan gagamit ng recursion:

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

Ang aming kondisyon sa pagtatapos ng recursion ay kapag naabot namin ang 1. Kung ang parameter ay hindi 1, pagkatapos ay i-multiply namin ang kasalukuyang halaga sa resulta ng susunod na recursive na tawag sa pamamaraan (kung saan ipinapasa namin ang kasalukuyang halaga na minus 1).

Solusyon sa isang Stream

Ang sinumang hindi pamilyar sa paggana ng Stream ng Java, o sinumang gustong i-refresh ang kanilang memorya, ay makikinabang sa pagbabasa tungkol dito .

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

Dito ginagamit namin ang espesyal na klase ng IntStream , na nagbibigay sa amin ng mga karagdagang kakayahan kapag nagtatrabaho sa isang stream ng mga halaga ng int. Para gumawa ng ganoong stream, ginagamit namin ang static na rangeClosed na paraan nito, na bumubuo ng mga value mula 2 hanggang f, inclusive, sa mga increment ng 1. Susunod, ginagamit namin ang reduce method para pagsamahin ang lahat ng value. Higit na partikular, ipinapakita namin ito kung paano namin gustong pagsamahin ang mga halaga. Sa wakas, nakukuha namin ang resultang halaga gamit ang terminal getAsInt method.

Gamit ang BigInteger

Sa Java, ang klase ng BigInteger ay kadalasang ginagamit upang pangasiwaan ang mga numero, lalo na ang MALAKING numero. Sa katunayan, kung gagamit tayo ng int , kung gayon ang maximum factorial na maaari nating hawakan nang walang pagkawala ng data ay 31. Para sa mahabang uri ng data, ang maximum factorial ay 39. Ngunit paano kung kailangan natin ang factorial na 100? Ibagay natin ang mga nakaraang solusyon sa BigInteger.

Ordinaryong solusyon

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

Ang algorithm ay mahalagang pareho, ngunit dito ginagamit namin ang mga kakayahan ng BigInteger: BigInteger.ONE ay ang panimulang halaga 1, at multiply() ay ginagamit upang i-multiply ang dating factorial value at ang kasalukuyang numero.

Recursive na solusyon

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

Ang pangkalahatang lohika ng solusyon ay hindi nagbabago, maliban na ang ilang mga pamamaraan ay idinagdag para sa pagtatrabaho sa BigInteger.

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

Ang lahat ay mahalagang pareho, ngunit sa BigInteger. Ang Stream class ay nagbibigay sa amin ng mapToObj method, na ginagamit namin upang i-convert ang mga int value sa BigInteger upang pagkatapos ay i-multiply ang mga ito sa kanilang mga sarili gamit ang multiply method (at get() ay idinagdag upang makakuha ng object mula sa Optional wrapper). Kung patakbuhin natin ang alinman sa tatlong pamamaraang ito na may argumento na 100, maiiwasan natin ang isang stack overflow at makuha ang tamang resulta: