Java-program för factorial

Idag ska vi prata om factorial och de vanligaste sätten att hitta factorial. Detta är en av de mest grundläggande funktionerna som en programmerare behöver både känna till och kunna arbeta med. Nåväl, låt oss börja. Faktorialen för talet n, betecknad som n!, är värdet av produkten (multiplikationen) av alla naturliga tal från 1 till n. Så här ser det ut (låt oss fräscha upp dina kunskaper om matematik): Och det finns ytterligare en liten regel för 0: Om vi ​​vill räkna ut skillnaden mellan 6! och 4!: Låt oss se hur detta skulle se ut när det implementeras i programmering. Vi kommer att utforska några sätt att göra beräkningar av faktorial i Java.

Vanlig lösning i faktoriellt program

Här är ett enkelt faktorprogram som använder 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);    
 }  
}

Vår utdata på konsolen kommer att vara: Och ytterligare ett exempel för att reda ut saker:

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

Inget svårt här: vi använder det godkända talet som storleken på vår slinga, där vi multiplicerar med alla föregående siffror tills vi kommer till f. Och i huvudsak:

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

När vi testar koden ser vi att vi får det önskade resultatet: 696.

Rekursiv lösning

Rekursion uppstår när en metod kallar sig själv. En sådan metod kallas för en rekursiv metod. Som regel består den av två delar:

1. Ett avslutande villkor — när det avslutande villkoret är uppfyllt bör metoden sluta anropa sig själv och börja skicka värden uppåt. När allt kommer omkring, om det inte finns något avslutande villkor, kommer vi att ha en oändlig loop, med metoden som anropar sig själv upprepade gånger tills vi får en StackOverflowError .
2. Vilken logik situationen än kräver plus ett rekursivt anrop, men med ett annat ingångsvärde.

Att hitta factorial i Java är ett perfekt exempel på när man ska använda rekursion:

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

Vårt rekursionsavslutande villkor kommer att vara när vi når 1. Om parametern inte är 1, multiplicerar vi det aktuella värdet med resultatet av nästa rekursiva anrop till metoden (till vilken vi skickar det aktuella värdet minus 1).

Lösning med en Stream

Alla som inte känner till Javas Stream-funktionalitet, eller någon som vill fräscha upp sitt minne, kommer att ha nytta av att läsa om hä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();
  }
}

Här använder vi den speciella IntStream- klassen, som ger oss ytterligare möjligheter när vi arbetar med en ström av int-värden. För att skapa en sådan ström använder vi dess statiska rangeClosed- metod, som genererar värden från 2 till f, inklusive, i steg om 1. Därefter använder vi reduceringsmetoden för att kombinera alla värden. Mer specifikt visar vi hur vi vill kombinera värderingarna. Slutligen får vi det resulterande värdet med hjälp av terminalen getAsInt -metoden.

Använder BigInteger

I Java används BigInteger -klassen ofta för att hantera siffror, speciellt BIG-tal. Faktum är att om vi använder int så är den maximala faktorialen som vi kan hantera utan dataförlust 31. För den långa datatypen är den maximala faktorialen 39. Men vad händer om vi behöver factorialen på 100? Låt oss anpassa de tidigare lösningarna till BigInteger.

Vanlig lösning

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

Algoritmen är i huvudsak densamma, men här använder vi BigInteger:s möjligheter: BigInteger.ONE är startvärdet 1, och multiply() används för att multiplicera det tidigare faktorvärdet och det aktuella talet.

Rekursiv lösning

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

Lösningens allmänna logik ändras inte, förutom att vissa metoder läggs till för att arbeta med BigInteger.

Lösning med en 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();
  }
}

Allt är i princip detsamma, men med BigInteger. Klassen Stream ger oss metoden mapToObj , som vi använder för att konvertera int-värden till BigInteger för att sedan multiplicera dem med sig själva med multiplikationsmetoden ( och get () lades till för att få ett objekt från Optional wrapper). Om vi ​​kör någon av dessa tre metoder med argumentet 100, kommer vi att undvika ett stackspill och få rätt resultat: