Java-program for factorial

I dag skal vi snakke om factorials og de vanligste måtene å finne factorial. Dette er en av de mest grunnleggende funksjonene som en programmerer trenger både å kjenne til og kunne jobbe med. Vel, la oss komme i gang. Faktorialet til tallet n, betegnet som n!, er verdien av produktet (multiplikasjonen) av alle naturlige tall fra 1 til n. Slik ser det ut (la oss friske opp kunnskapen din om matematikk): Og det er en liten regel til for 0: Hvis vi vil beregne differansen mellom 6! og 4!: La oss se hvordan dette vil se ut når det implementeres i programmering. Vi vil utforske noen måter å gjøre beregninger av faktorial i Java.

Ordinær løsning i faktorielt program

Her er et enkelt faktorprogram som bruker 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);    
 }  
}

Utgangen vår på konsollen vil være: Og ett eksempel til for å ordne opp:

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

Ikke noe vanskelig her: vi bruker det beståtte tallet som størrelsen på løkken vår, der vi multipliserer med alle de foregående tallene til vi kommer til f. Og i hovedsak:

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

Ved å teste koden ser vi at vi får ønsket resultat: 696.

Rekursiv løsning

Rekursjon skjer når en metode kaller seg selv. En slik metode kalles en rekursiv metode. Som regel består den av to deler:

1. En terminerende betingelse - når termineringsbetingelsen er oppfylt, bør metoden slutte å kalle seg selv og begynne å sende verdier opp. Tross alt, hvis det ikke er noen terminerende betingelse, vil vi ha en uendelig løkke, med metoden som kaller seg selv gjentatte ganger til vi får en StackOverflowError .
2. Uansett hvilken logikk situasjonen krever pluss et rekursivt anrop, men med en annen inngangsverdi.

Å finne faktoren i Java er et perfekt eksempel på når du skal bruke rekursjon:

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år rekursjonsavslutningsbetingelse vil være når vi når 1. Hvis parameteren ikke er 1, multipliserer vi den nåværende verdien med resultatet av neste rekursive kall til metoden (som vi sender gjeldende verdi minus 1 til).

Løsning med en Stream

Alle som ikke er kjent med Javas Stream-funksjonalitet, eller alle som ønsker å friske opp hukommelsen, vil ha nytte av å lese om her .

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

Her bruker vi den spesielle IntStream- klassen, som gir oss ekstra muligheter når vi jobber med en strøm av int-verdier. For å lage en slik strøm bruker vi dens statiske rangeClosed- metoden, som genererer verdier fra 2 til f, inklusive, i trinn på 1. Deretter bruker vi reduseringsmetoden for å kombinere alle verdiene. Mer spesifikt viser vi hvordan vi ønsker å kombinere verdiene. Til slutt får vi den resulterende verdien ved å bruke terminal getAsInt -metoden.

Bruker BigInteger

I Java brukes BigInteger- klassen ofte til å håndtere tall, spesielt STORE tall. Faktisk, hvis vi bruker int , er den maksimale faktoren som vi kan håndtere uten tap av data 31. For den lange datatypen er den maksimale faktoren 39. Men hva om vi trenger faktoren på 100? La oss tilpasse de tidligere løsningene til 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 er i hovedsak den samme, men her bruker vi BigInteger sine muligheter: BigInteger.ONE er startverdien 1, og multiply() brukes til å multiplisere forrige faktorverdi og gjeldende tall.

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

Den generelle logikken til løsningen endres ikke, bortsett fra at noen metoder er lagt til for å jobbe 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();
  }
}

Alt er i hovedsak det samme, men med BigInteger. Stream-klassen gir oss mapToObj- metoden, som vi bruker til å konvertere int-verdier til BigInteger for deretter å multiplisere dem med seg selv ved hjelp av multiplikasjonsmetoden ( og get() ble lagt til for å få et objekt fra den valgfrie wrapperen). Hvis vi kjører noen av disse tre metodene med et argument på 100, vil vi unngå stabeloverflyt og få riktig resultat: