Faktorial för ett tal är ett viktigt matematiskt begrepp. Du kan använda den för att utföra permutationer och kombinationer, skriva exponentiella och logaritmiska uttryck och beräkna sannolikhet.

Du använder den för att hitta hur många olika sätt du kan designa ett sittarrangemang eller välja t-shirts för din semester till Maldiverna. Men hur kan du räkna ut faktorn för ett tal?

Vad är faktorn för ett nummer?

Faktorialen för ett positivt tal är produkten av alla positiva heltal mindre än eller lika med värdet på själva talet. En siffra följt av ett utropstecken(!) anger ett tals fakultet. Du representerar fakulteten av fem som 5! och beräkna det som:

5! = 5 * 4 * 3 * 2 * 1 = 120

Ett annat sätt att visualisera det är:

5! = 5 * 4! var 4! = 4 * 3!, 3! = 3 * 2! och så vidare tills du får 1! = 1 * 0! vilket är 1.

Du kommer att använda detta koncept för att bygga vårt faktorprogram med ett populärt koncept som kallas rekursion.

Vad är rekursion?

Rekursion är en process där en funktion anropar sig själv. En av de största fördelarna med denna process är att den delar upp ett större problem i mindre bitar. Detta gör problemet lättare att lösa.

instagram viewer

Du kan använda rekursion för att lösa lämpliga problem i tre enkla steg:

  1. Hitta grundfallet: Om en funktion alltid anropar sig själv kommer processen att vara oändlig. För att förhindra att detta händer, definiera ett basfall som blir den logiska stopppunkten för din funktion. Till exempel, i ett faktorprogram, stoppa beräkningen vid noll. Detta blir grundfallet för problemet.
  2. Hitta sambandet mellan problemet och delproblemen: Bryt ner det större problemet i ett delproblem. Till exempel är problemet att hitta faktorn fem. Anta att du har svaret på faktor fyra, det vill säga 24. Hur kommer du att få faktorvärdet på fem med 24? Genom att multiplicera sig själv med fem. Detta är förhållandet mellan problemet och delproblemet.
  3. Generalisera relationen i steg 2: Nu när du har relationen, generalisera den i termer av n. Så, faktorialen av ett tal n är produkten av n och faktorialen av n-1.

Du kan använda detta koncept för att hitta summan av n naturliga tal, beräkna GCD, LCM, Fibonacci-serien och kontrollera primtal.

Pseudokod för den faktoriella funktionen med hjälp av rekursion

Detta är hur du använder rekursion och skriv pseudokoden för att bygga ditt program på valfritt språk. Med olika språk ändras syntaxen och exekveringen men logiken förblir intakt.

fungeraFaktum(n)
 Om n == 0 sedan // basfallet
Lämna tillbaka1
Lämna tillbaka n * Samtalsfakta (n - 1) // generaliserad relation

Faktaprogram i C

C var det första plattformsoberoende programmeringsspråket på hög nivå. Den har strikt syntax, är skiftlägeskänslig och kör kod med den snabbaste hastigheten. Det är ett procedurmässigt programmeringsspråk och därför deklarerar du vilken funktion som helst ovanpå huvud fungera. Så här kan du bygga det faktoriella programmet med hjälp av rekursion i C-språk:

Du kan hitta hela källkoden för det faktoriella programmet med hjälp av rekursion i C, Java och Python i detta GitHub-förråd.

  1. Importera standardfilen för utdatahuvudet för att visa utdata på skärmen.
    #omfatta <stdio.h>
  2. Definiera funktion faktum och ta heltal n som ett argument.
    intfaktum(int n){
  3. Skriv basfallet för funktionen med hjälp av om uttalande och kontrollera dess likvärdighet med hjälp av ==. Om n är lika med noll, returnera ett.
     om (n == 0)
    lämna tillbaka1;
  4. Skriv den generaliserade ekvationen och returnera produkten av n med ett funktionsanrop av underproblem n-1.
    lämna tillbaka n * faktum (n - 1);
    }
  5. Deklarera huvudfunktionen och initiera en variabel av heltalstyp för att lagra talet vars faktor du vill hitta.
    inthuvud(){
    int num = 5;
  6. Visa numrets fakultet med hjälp av printf() fungera. %d är decimalformatsspecifikationen. Använd var och en av formatspecifikationerna för att ersätta den med talet vars faktor du vill hitta och få resultatet genom att anropa funktionen.
     printf("Faktor för %d är %d", num, faktum (num));
    lämna tillbaka0;
    }

Faktaprogram i Java

Java är ett kompilerat programmeringsspråk och är plattformsoberoende. Du lagrar all kod i en klass och utförandet börjar från huvud fungera. Det är skiftlägeskänsligt och syntaxstrikt. Koden är lite längre men snabbare jämfört med Python. Så här kan du bygga det faktoriella programmet med hjälp av rekursion i Java:

  1. Definiera huvudklassen.
    klassMain{
  2. Definiera en statisk funktion med returtyp int som accepterar en variabel n av heltalstyp. Du deklarerade en statisk metod eftersom huvudmetoden i Java också deklareras som statisk. Dessutom kan du inte anropa en icke-statisk metod från en statisk instans.
    statiskintfaktum(int n){
  3. Skriv basfallet för funktionen med hjälp av om uttalande och kontrollera dess likvärdighet med hjälp av ==. Om n är lika med noll, returnera ett.
     om (n == 0)
    lämna tillbaka1;
  4. Skriv den generaliserade ekvationen och returnera produkten av n med ett funktionsanrop av underproblem n-1.
    lämna tillbaka n * faktum (n - 1);
     }
  5. Deklarera huvudfunktionen i Java. Deklarera åtkomstmodifieraren som offentlig, så det kan vara tillgängligt för alla andra klasser och metoder. Du deklarerar huvudfunktionen som statisk så att kompilatorn kan anropa den utan att instansiera klassen. Returtypen är tomhet, och den accepterar typargument Sträng. Lagra numret vars factorial du vill hitta.
    offentligstatisktomhethuvud(String[] args){
    int num = 5;
  6. Använd println() metod, en instans av PrintStream klass, definierad i Systemet klass för att visa numrets faktor.
     System.out.println("Faktoriell av " + num + " är " + fakta (antal));
     }
    }

Faktaprogram i Python

Att skriva kod i Python är superenkelt och roligt. Eftersom det är ett tolkat plattformsoberoende språk, behöver du inte deklarera datatypen för variabler. Du slipper också deklarera klasser och importera bibliotek för ett så enkelt program. Lekplatsen är redo för dig att börja koda.

Syntaxen är enklare, med en liten kodlängd men tar lite längre tid att köra än de andra språken. Så här kan du bygga det faktoriella programmet med hjälp av rekursion i Python:

  1. Definiera funktionsfaktum som accepterar som argument n.
    deffaktum(n):
  2. Skriv basfallet för funktionen med hjälp av om uttalande och kontrollera dess likvärdighet med hjälp av ==. Om n är lika med noll, returnera ett.
     om n == 0:
    lämna tillbaka1
  3. Skriv den generaliserade ekvationen och returnera produkten av n med ett funktionsanrop av underproblem n-1.
    lämna tillbaka n * faktum (n-1)
  4. Lagra numret vars factorial du vill hitta och visa det med utskriftssatsen.
    num = 5;
    skriva ut("Faktoriell av", num, "är", faktum (antal))

Det finns många tillämpningar av rekursion

Rekursion är ett effektivt sätt att lösa problem. Det är kärnan i artificiell intelligens och har verkliga användningsområden i pusselspel som schack eller Sudoku.

Det är också en kraftfull metod för att sortera datastrukturer som träd eller sorteringsalgoritmer som snabbsortering och sammanfogningssortering. Du kan också använda rekursion i sökalgoritmer som binär sökning, matematiska uttryck som Fibonacci-serien och mer.