Java-programma voor faculteit

Vandaag gaan we het hebben over faculteiten en de meest gebruikelijke manieren om faculteiten te vinden. Dit is een van de meest basale functies die een programmeur moet kennen en waarmee hij moet kunnen werken. Nou, laten we beginnen. De faculteit van het getal n, aangeduid als n!, is de waarde van het product (vermenigvuldiging) van alle natuurlijke getallen van 1 tot n. Zo ziet het eruit (laten we je kennis van wiskunde opfrissen): En er is nog een kleine regel voor 0: Als we het verschil tussen 6 willen berekenen! en 4!: Laten we eens kijken hoe dit eruit zou zien als het in de programmering zou worden geïmplementeerd. We zullen een paar manieren onderzoeken om faculteiten in Java te berekenen.

Gewone oplossing in faculteitsprogramma

Hier is een eenvoudig faculteitsprogramma dat een lus gebruikt:

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

Onze output op console zal zijn: En nog een voorbeeld om de zaken op een rijtje te zetten:

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

Niets moeilijks hier: we gebruiken het doorgegeven getal als de grootte van onze lus, waarin we vermenigvuldigen met alle voorgaande getallen totdat we bij f komen. En in hoofdzaak:

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

Bij het testen van de code zien we dat we het gewenste resultaat krijgen: 696.

Recursieve oplossing

Recursie vindt plaats wanneer een methode zichzelf aanroept. Zo'n methode wordt een recursieve methode genoemd. In de regel bestaat het uit twee delen:

1. Een beëindigingsvoorwaarde — wanneer aan de beëindigingsvoorwaarde is voldaan, moet de methode zichzelf niet meer aanroepen en beginnen met het doorgeven van waarden. Immers, als er geen beëindigingsvoorwaarde is, hebben we een oneindige lus, waarbij de methode zichzelf herhaaldelijk aanroept totdat we een StackOverflowError krijgen .
2. Welke logica de situatie ook vereist, plus een recursieve aanroep, maar met een andere invoerwaarde.

Het vinden van de faculteit in Java is een perfect voorbeeld van wanneer recursie moet worden gebruikt:

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

Onze voorwaarde voor het beëindigen van de recursie is wanneer we 1 bereiken. Als de parameter niet 1 is, vermenigvuldigen we de huidige waarde met het resultaat van de volgende recursieve aanroep van de methode (waaraan we de huidige waarde minus 1 doorgeven).

Oplossing met een stroom

Iedereen die niet bekend is met de Stream-functionaliteit van Java, of iedereen die zijn geheugen wil opfrissen, kan hier wat over lezen .

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

Hier gebruiken we de speciale IntStream- klasse, die ons extra mogelijkheden geeft bij het werken met een stroom van int-waarden. Om zo'n stream te maken, gebruiken we de statische methode rangeClosed , die waarden genereert van 2 tot en met f, in stappen van 1. Vervolgens gebruiken we de reduce-methode om alle waarden te combineren. Meer specifiek laten we zien hoe we de waarden willen combineren. Ten slotte krijgen we de resulterende waarde met behulp van de terminal getAsInt -methode.

BigInteger gebruiken

In Java wordt de BigInteger- klasse vaak gebruikt om getallen te verwerken, vooral GROTE getallen. Inderdaad, als we int gebruiken , dan is de maximale faculteit die we aankunnen zonder gegevensverlies 31. Voor het lange gegevenstype is de maximale faculteit 39. Maar wat als we de faculteit van 100 nodig hebben? Laten we de vorige oplossingen aanpassen aan BigInteger.

Gewone oplossing

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

Het algoritme is in wezen hetzelfde, maar hier gebruiken we de mogelijkheden van BigInteger: BigInteger.ONE is de startwaarde 1, en vermenigvuldigen() wordt gebruikt om de vorige faculteitswaarde en het huidige getal te vermenigvuldigen.

Recursieve oplossing

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

De algemene logica van de oplossing verandert niet, behalve dat er enkele methoden worden toegevoegd voor het werken met BigInteger.

Oplossing met een stroom

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

Alles is in wezen hetzelfde, maar dan met BigInteger. De klasse Stream geeft ons de methode mapToObj , die we gebruiken om int-waarden om te zetten in BigInteger om ze vervolgens met zichzelf te vermenigvuldigen met behulp van de methode vermenigvuldigen (en get() is toegevoegd om een ​​object uit de optionele verpakking te halen). Als we een van deze drie methoden uitvoeren met een argument van 100, voorkomen we een stackoverloop en krijgen we het juiste resultaat: