Java-program til factorial

I dag skal vi tale om factorials og de mest almindelige måder at finde factorial på. Dette er en af ​​de mest basale funktioner, som en programmør både skal kende og kunne arbejde med. Nå, lad os komme i gang. Faktorialet for tallet n, betegnet som n!, er værdien af ​​produktet (multiplikationen) af alle naturlige tal fra 1 til n. Sådan ser det ud (lad os genopfriske din viden om matematik): Og der er endnu en lille regel for 0: Hvis vi vil beregne forskellen mellem 6! og 4!: Lad os se, hvordan dette ville se ud, når det implementeres i programmering. Vi vil undersøge et par måder at udføre beregninger af faktorielle i Java.

Almindelig løsning i faktorielt program

Her er et simpelt faktorprogram, der bruger 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);    
 }  
}

Vores output på konsollen vil være: Og endnu et eksempel til at ordne tingene:

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

Intet svært her: vi bruger det beståede tal som størrelsen på vores løkke, hvor vi gange med alle de foregående tal, indtil vi kommer til f. Og i hovedsagen:

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

Ved at teste koden ser vi, at vi får det ønskede resultat: 696.

Rekursiv løsning

Rekursion sker, når en metode kalder sig selv. Sådan en metode kaldes en rekursiv metode. Som regel består den af ​​to dele:

1. En afsluttende betingelse — når den afsluttende betingelse er opfyldt, bør metoden stoppe med at kalde sig selv og begynde at sende værdier op. Når alt kommer til alt, hvis der ikke er nogen terminerende betingelse, vil vi have en uendelig løkke, hvor metoden kalder sig selv gentagne gange, indtil vi får en StackOverflowError .
2. Uanset hvilken logik situationen kræver plus et rekursivt kald, men med en anden inputværdi.

At finde factorial i Java er et perfekt eksempel på, hvornår man skal bruge 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);
  }
}

Vores rekursionsterminerende betingelse vil være, når vi når 1. Hvis parameteren ikke er 1, så multiplicerer vi den aktuelle værdi med resultatet af det næste rekursive kald til metoden (som vi sender den aktuelle værdi minus 1).

Løsning med en Stream

Enhver, der ikke er bekendt med Javas Stream-funktionalitet, eller enhver, der ønsker at genopfriske deres hukommelse, vil have gavn af at læse 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 bruger vi den specielle IntStream- klasse, som giver os yderligere muligheder, når vi arbejder med en strøm af int-værdier. For at skabe sådan en strøm bruger vi dens statiske rangeClosed- metode, som genererer værdier fra 2 til f, inklusive, i trin på 1. Dernæst bruger vi reduceringsmetoden til at kombinere alle værdierne. Helt konkret viser vi det, hvordan vi vil kombinere værdierne. Til sidst får vi den resulterende værdi ved hjælp af terminal getAsInt -metoden.

Brug af BigInteger

I Java bruges BigInteger -klassen ofte til at håndtere tal, især BIG-tal. Faktisk, hvis vi bruger int , så er den maksimale factorial, som vi kan håndtere uden datatab, 31. For den lange datatype er den maksimale factorial 39. Men hvad nu hvis vi har brug for factorial på 100? Lad os tilpasse de tidligere løsninger til BigInteger.

Almindelig 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 det væsentlige den samme, men her bruger vi BigInteger's muligheder: BigInteger.ONE er startværdien 1, og multiply() bruges til at multiplicere den tidligere faktorielle værdi og det aktuelle tal.

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 generelle logik ændres ikke, bortset fra at nogle metoder er tilføjet til at arbejde 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 stort set det samme, men med BigInteger. Stream-klassen giver os mapToObj- metoden, som vi bruger til at konvertere int-værdier til BigInteger for derefter at gange dem med sig selv ved hjælp af multiplikationsmetoden ( og get() blev tilføjet for at få et objekt fra Optional wrapper). Hvis vi kører en af ​​disse tre metoder med et argument på 100, så undgår vi et stackoverløb og får det korrekte resultat: