Fn = Fn-1 + Fn-2
Denna handledning kommer att innehålla olika metoder för att skapa en sekvens av Fibonacci-nummer.
Exempel 1
I det här exemplet används först biblioteket med in- och utströmmar för att aktivera cin- och cout-strömmarna, plus att användarens engagemang också uppmuntras genom detta bibliotek. Inuti huvudprogrammet kommer vi att ta två heltalsvariabler och deklarera dem som nollvärde. En annan nextterm-variabel används också som initieras som noll och placeras för senare användning. Vi kommer att be användaren att ange ett nummer han behöver i Fibonacci-serien. Med andra ord, antalet rader som visas som utdata beror på användarens inmatning. Det specifika nummer som användaren kommer att ange, kommer resultatet att innehålla svaret på dessa rader.
Vi behöver en 'för'-loop för att iterera upp till det specifika numret som användaren anger för att beräkna sekvensen. Detta är en sorts gräns med flera rader. En if-sats används för att kontrollera numret; om det är en, visa den som den är utan någon förändring. På samma sätt kommer det andra numret att visas på samma sätt. I Fibonacci-sekvensen visas de två första siffrorna. För att gå vidare har vi använt fortsätt-satsen. För att beräkna serien vidare lägger vi till båda värdena. Och det här blir det tredje numret i serien. Efter att bytesprocessen startar kommer den första variabeln att tilldelas värdet för den andra variabeln, och den andra variabeln kommer att innehålla det tredje värdet lagrat i nästa termvariabel.
Nästa term = t1 + t2;
Ti = t2;
T2 =nästa term;
Nu visas varje värde separerat med kommatecken. Kör koden genom en kompilator. '-o' används för att spara utdata från koden som finns i indatafilen.
$ g++ -O fib fib.c$ . / fib
Du kan se att när programmet körs kommer användaren att be om att ange numret han har angett 7, då blir resultatet på 7 rader, oavsett när Fibonacci-serien har nått den 7:e punkten.
Exempel 2
Detta exempel kommer att innehålla beräkningen av Fibonacci-serien genom att begränsa nästa termvärde. Detta innebär att Fibonacci-serien kan anpassas genom att ange ett specificerat antal i vilken utsträckning du vill. Till skillnad från föregående exempel beror resultatet inte på antalet rader utan på antalet serier som ges av ett tal. Vi kommer att utgå från huvudprogrammet, variablerna är desamma, och tillvägagångssättet för användarengagemang är detsamma. Så de två första variablerna initieras som noll i början, nästa termvariabel deklareras som noll. Då kommer användaren att ange numret. De två första termerna visas då som alltid är 0 och 1.
Nästa termvärde kommer att tilldelas det värde som erhålls genom att addera siffrorna som finns i de två första variablerna. Här används en while-loop för att tillämpa ett villkor för att skapa serien tills värdet i nästa termvariabel är lika med eller mindre än talet som användaren ger.
medan (nästa term <= n)
Inuti denna while-loop kommer logiken att tillämpas genom att byta siffror i riktning bakåt. Nextterm-variabeln kommer återigen att lägga till värdena för variabler.
Nästa term = t1 + t2;
Spara nu filen och kompilera den för att exekvera koden i terminalen.
När du kör koden kommer systemet att kräva ett nummer från dig som måste vara ett positivt tal. Då kommer du att se att vid beräkningen visas en serie siffror tills det 55:e talet.
Exempel 3
Denna källkod som vi kommer att nämna kommer att innehålla en annan metod för att beräkna Fibonacci-serien. Hittills har vi beräknat serien i huvudprogrammet. Det här exemplet använder en separat funktion för att beräkna denna talföljd. Inuti funktionen görs ett rekursivt anrop för att fortsätta processen. Därför är det också ett exempel på rekursion. Funktionen tar numret i parametern, upp till vilket serien ska beräknas. Detta nummer skickas från huvudprogrammet. En if-sats används för att kontrollera om talet är mindre än eller lika med 1, returnera sedan själva talet eftersom vi behöver minst två tal för att beräkna serien. I det andra fallet, när villkoret blir falskt och talet är större än 1, beräkna serien genom att upprepade gånger använda ett rekursivt anrop till själva funktionen.
Fib (n-1) + fib (n-2);
Detta visar att i den första delen, ett tal innan det totala antalet skickas till funktionen, kommer det värdet att subtraheras från talet som erhålls från cellen som innehåller två siffror före det totala antalet som en parameter.
Nu i huvudprogrammet tilldelas variabeln numret och det första funktionsanropet görs för att skicka numret till funktionen. Kör nu filens källkod i terminalen för att få svaret. Här kommer du att se att '13' är svaret, eftersom siffran som angavs var 7, så serien blir 0+1+1+2+3+5+8+13.
Exempel 4
Detta exempel involverar OOP-metoden (objektorienterad programmering) för att beräkna Fibonacci-serien. En klass GFG skapas. I dess publika del skapas en funktion för att ha en array som ska lagra Fibonacci-serien.
F [n+2];
Här är n talet som anges som 0 i början.
F[0] = 0;
F[l] = 1;
Siffrorna vid index 0 och 1 deklareras som 0 och 1.
Därefter används en 'for'-loop där Fibonacci-serien kommer att beräknas. De två föregående numren läggs till serien och kommer att lagras.
F[i] = f[i-1] + f[i-2];
Därefter returneras det specifika numret vid ett visst index.
Ett funktionsanrop görs med hjälp av objektet.
g.fib(n);
Kör nu koden och du kommer att se att eftersom numret är 11 kommer sekvensen att vara till den 11:e siffran.
Slutsats
Den här artikeln 'Fibonacci-sekvens C++' är en blandning av olika metoder som används för att skapa en sekvens genom att lägga till de två föregående talen. Med en enkel växlingsteknik kan vi, förutom rekursionsmetoden och med hjälp av arrayer, generera dessa tal i serie. För att skapa Fibonacci-serien rekommenderas siffrorna att vara i heltalsdatatyp. Vi kan beräkna serien genom att tillämpa begränsningar på antalet rader och sekvensens antal.