Fn = Fn-1 + Fn-2
ఈ ట్యుటోరియల్‌లో ఫైబొనాక్సీ సంఖ్యల క్రమాన్ని రూపొందించడానికి వివిధ పద్ధతులు ఉంటాయి.
ఉదాహరణ 1
ఈ ఉదాహరణలో, ముందుగా, సిన్ మరియు కౌట్ స్ట్రీమ్‌లను ప్రారంభించడానికి ఇన్‌పుట్ మరియు అవుట్‌పుట్ స్ట్రీమ్‌ల లైబ్రరీ ఉపయోగించబడుతుంది, అంతేకాకుండా ఈ లైబ్రరీ ద్వారా వినియోగదారు ప్రమేయం కూడా ప్రోత్సహించబడుతుంది. ప్రధాన ప్రోగ్రామ్ లోపల, మేము రెండు పూర్ణాంక-రకం వేరియబుల్స్ తీసుకుంటాము మరియు వాటిని సున్నా విలువగా ప్రకటిస్తాము. మరొక నెక్స్ట్ టర్మ్ వేరియబుల్ కూడా ఉపయోగించబడుతుంది, అది సున్నాగా ప్రారంభించబడింది మరియు తరువాత ఉపయోగం కోసం ఉంచబడుతుంది. ఫైబొనాక్సీ సిరీస్‌లో వినియోగదారుకు అవసరమైన సంఖ్యను నమోదు చేయమని మేము అడుగుతాము. మరో మాటలో చెప్పాలంటే, అవుట్‌పుట్‌గా ప్రదర్శించబడే పంక్తుల సంఖ్య వినియోగదారు ఇన్‌పుట్‌పై ఆధారపడి ఉంటుంది. వినియోగదారు నమోదు చేసే నిర్దిష్ట సంఖ్య, ఫలితం ఈ పంక్తులలో సమాధానాన్ని కలిగి ఉంటుంది.
క్రమాన్ని లెక్కించడానికి వినియోగదారు నమోదు చేసే నిర్దిష్ట సంఖ్య వరకు పునరావృతం చేయడానికి మనకు ‘ఫర్’ లూప్ అవసరం. ఇది అనేక పంక్తుల ద్వారా ఒక విధమైన పరిమితి. సంఖ్యను తనిఖీ చేయడానికి if స్టేట్‌మెంట్ ఉపయోగించబడుతుంది; అది ఒకటి అయితే, దానిని ఎలాంటి మార్పు లేకుండా అలాగే ప్రదర్శించండి. అదేవిధంగా, రెండవ సంఖ్య కూడా ప్రదర్శించబడుతుంది. ఫైబొనాక్సీ సీక్వెన్స్‌లో, మొదటి రెండు సంఖ్యలు ప్రదర్శించబడతాయి. ముందుకు సాగడానికి, మేము కొనసాగించు ప్రకటనను ఉపయోగించాము. శ్రేణిని మరింత లెక్కించడానికి, మేము రెండు విలువలను జోడిస్తాము. మరియు ఇది సిరీస్‌లో మూడవ నంబర్ అవుతుంది. ఆ మార్పిడి ప్రక్రియ ప్రారంభమైన తర్వాత, మొదటి వేరియబుల్‌కు రెండవ వేరియబుల్ విలువ కేటాయించబడుతుంది మరియు రెండవ వేరియబుల్ తదుపరి టర్మ్ వేరియబుల్‌లో నిల్వ చేయబడిన మూడవ విలువను కలిగి ఉంటుంది.
Nextterm = t1 + t2;
T1 = t2;
T2 = తదుపరి;
ఇప్పుడు ప్రతి విలువ కామాలతో వేరు చేయబడి ప్రదర్శించబడుతుంది. కంపైలర్ ద్వారా కోడ్‌ని అమలు చేయండి. ఇన్‌పుట్ ఫైల్‌లో ఉన్న కోడ్ అవుట్‌పుట్‌ను సేవ్ చేయడానికి ‘-o’ ఉపయోగించబడుతుంది.
$ g++ -ఓ fib fib.c$ / fib
ప్రోగ్రామ్ అమలు చేయబడినప్పుడు, వినియోగదారు అతను నమోదు చేసిన 7 సంఖ్యను నమోదు చేయమని అడుగుతారని మీరు చూడవచ్చు, అప్పుడు ఫలితం 7 పంక్తులుగా ఉంటుంది, ఏ సమయంలో ఫైబొనాక్సీ సిరీస్ 7వ పాయింట్‌కి చేరుకుంది.
ఉదాహరణ 2
ఈ ఉదాహరణ తరువాతి విలువను పరిమితం చేయడం ద్వారా ఫైబొనాక్సీ సిరీస్ యొక్క గణనను కలిగి ఉంటుంది. దీనర్థం ఫిబొనాక్సీ సిరీస్‌ను మీరు కోరుకున్నంత మేరకు నిర్దేశిత సంఖ్యను అందించడం ద్వారా అనుకూలీకరించవచ్చు. మునుపటి ఉదాహరణ వలె కాకుండా, ఫలితం పంక్తుల సంఖ్యపై కాకుండా సంఖ్య ద్వారా అందించబడిన శ్రేణుల సంఖ్యపై ఆధారపడి ఉంటుంది. మేము ప్రధాన ప్రోగ్రామ్ నుండి ప్రారంభిస్తాము, వేరియబుల్స్ ఒకేలా ఉంటాయి మరియు వినియోగదారు ప్రమేయం యొక్క విధానం కూడా అలాగే ఉంటుంది. కాబట్టి రెండు మొదటి వేరియబుల్స్ ప్రారంభంలో సున్నాగా ప్రారంభించబడతాయి, తరువాతి వేరియబుల్ సున్నాగా ప్రకటించబడుతుంది. అప్పుడు వినియోగదారు నంబర్‌ను నమోదు చేస్తారు. మొదటి రెండు పదాలు ఎల్లప్పుడూ 0 మరియు 1గా ప్రదర్శించబడతాయి.
మొదటి రెండు వేరియబుల్స్‌లో ఉన్న సంఖ్యలను జోడించడం ద్వారా పొందిన విలువ తదుపరి టర్మ్ విలువకు కేటాయించబడుతుంది. నెక్స్ట్‌టర్మ్ వేరియబుల్‌లోని విలువ వినియోగదారు ఇచ్చే సంఖ్యకు సమానంగా లేదా అంతకంటే తక్కువగా ఉండే వరకు సిరీస్‌ను సృష్టించే షరతును వర్తింపజేయడానికి ఇక్కడ కాసేపు లూప్ ఉపయోగించబడుతుంది.
అయితే (తదుపరి <= n)
ఈ while లూప్ లోపల, వెనుకవైపు దిశలో సంఖ్యలను మార్చుకోవడం ద్వారా లాజిక్ వర్తించబడుతుంది. నెక్స్ట్ టర్మ్ వేరియబుల్ మళ్లీ వేరియబుల్స్ విలువలను జోడిస్తుంది.
Nextterm = t1 + t2;
ఇప్పుడు ఫైల్‌ను సేవ్ చేసి, టెర్మినల్‌లో కోడ్‌ను అమలు చేయడానికి కంపైల్ చేయండి.
మీరు కోడ్‌ను అమలు చేసినప్పుడు, సిస్టమ్ మీ నుండి ఒక సంఖ్యను డిమాండ్ చేస్తుంది, అది తప్పనిసరిగా సానుకూల సంఖ్యగా ఉండాలి. అప్పుడు మీరు గణనలో, 55 వ సంఖ్య వరకు సంఖ్యల శ్రేణి ప్రదర్శించబడుతుందని మీరు చూస్తారు.
ఉదాహరణ 3
మేము ప్రస్తావించబోయే ఈ సోర్స్ కోడ్ ఫిబొనాక్సీ సిరీస్‌ని లెక్కించే వేరొక పద్ధతిని కలిగి ఉంటుంది. ఇప్పటి వరకు, మేము ప్రధాన ప్రోగ్రామ్‌లోని సిరీస్‌ని లెక్కించాము. ఈ ఉదాహరణ సంఖ్యల క్రమాన్ని లెక్కించడానికి ప్రత్యేక ఫంక్షన్ యొక్క ప్రమేయాన్ని ఉపయోగిస్తుంది. ఫంక్షన్ లోపల, ప్రక్రియను కొనసాగించడానికి పునరావృత కాల్ చేయబడుతుంది. అందుకే ఇది రికర్షన్‌కి కూడా ఉదాహరణ. ఫంక్షన్ పరామితిలోని సంఖ్యను తీసుకుంటుంది, దాని వరకు సిరీస్ లెక్కించబడుతుంది. ఈ సంఖ్య ప్రధాన ప్రోగ్రామ్ నుండి పంపబడింది. సంఖ్య 1 కంటే చిన్నదా లేదా సమానంగా ఉందా అని తనిఖీ చేయడానికి if స్టేట్‌మెంట్ ఉపయోగించబడుతుంది, ఆపై సిరీస్‌ను గణించడానికి మనకు కనీసం రెండు సంఖ్యలు అవసరం కాబట్టి సంఖ్యను తిరిగి ఇవ్వండి. రెండవ సందర్భంలో, పరిస్థితి తప్పుగా మారినప్పుడు మరియు సంఖ్య 1 కంటే ఎక్కువగా ఉన్నప్పుడు, ఫంక్షన్‌కు పునరావృత కాల్‌ని పదేపదే ఉపయోగించడం ద్వారా సిరీస్‌ను లెక్కించండి.
Fib (n-1) + fib (n-2);
ఇది మొదటి భాగంలో, మొత్తం సంఖ్యను ఫంక్షన్‌కు పంపే ముందు ఒక సంఖ్య, ఆ విలువ మొత్తం సంఖ్యకు ముందు ఉన్న రెండు సంఖ్యలను పారామీటర్‌గా కలిగి ఉన్న సెల్ నుండి పొందిన సంఖ్య నుండి తీసివేయబడుతుంది.
ఇప్పుడు ప్రధాన ప్రోగ్రామ్‌లో, నంబర్ వేరియబుల్‌కు కేటాయించబడుతుంది మరియు నంబర్‌ను ఫంక్షన్‌కు పంపడానికి మొదటి ఫంక్షన్ కాల్ చేయబడుతుంది. ఇప్పుడు సమాధానం పొందడానికి టెర్మినల్‌లో ఫైల్ సోర్స్ కోడ్‌ని అమలు చేయండి. ఇక్కడ మీరు '13' సమాధానం అని చూస్తారు, ఎందుకంటే నమోదు చేసిన సంఖ్య 7, కాబట్టి సిరీస్ 0+1+1+2+3+5+8+13 అవుతుంది.
ఉదాహరణ 4
ఈ ఉదాహరణ ఫైబొనాక్సీ సిరీస్‌ను లెక్కించే OOP (ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్) విధానాన్ని కలిగి ఉంటుంది. ఒక తరగతి GFG సృష్టించబడింది. దాని పబ్లిక్ భాగంలో, ఫైబొనాక్సీ సిరీస్‌ను నిల్వ చేసే శ్రేణిని కలిగి ఉండేలా ఒక ఫంక్షన్ సృష్టించబడింది.
F [n +2];
ఇక్కడ n అనేది ప్రారంభంలో 0గా ప్రకటించబడిన సంఖ్య.
F[0] = 0;
F[1] = 1;
ఇండెక్స్ 0 మరియు 1 వద్ద ఉన్న సంఖ్యలు 0 మరియు 1గా ప్రకటించబడ్డాయి.
ఆ తర్వాత, 'ఫర్' లూప్ ఉపయోగించబడుతుంది, దీనిలో ఫైబొనాక్సీ సిరీస్ లెక్కించబడుతుంది. మునుపటి రెండు సంఖ్యలు సిరీస్‌కి జోడించబడ్డాయి మరియు నిల్వ చేయబడతాయి.
F[i] = f[i-1] + f[i -2];
ఆ తర్వాత, నిర్దిష్ట సూచికలోని నిర్దిష్ట సంఖ్య తిరిగి ఇవ్వబడుతుంది.
ఆబ్జెక్ట్‌ని ఉపయోగించడం ద్వారా ఫంక్షన్ కాల్ చేయబడుతుంది.
g.fib(n);
ఇప్పుడు కోడ్‌ని అమలు చేయండి మరియు సంఖ్య 11 అయినందున, క్రమం 11వ అంకె వరకు ఉంటుందని మీరు చూస్తారు.
ముగింపు
ఈ కథనం ‘ఫైబొనాక్సీ సీక్వెన్స్ C++’ అనేది మునుపటి రెండు సంఖ్యలను జోడించడం ద్వారా క్రమాన్ని రూపొందించడానికి ఉపయోగించే విభిన్న విధానాల మిశ్రమం. సరళమైన స్వాపింగ్ టెక్నిక్‌తో, రికర్షన్ పద్ధతితో పాటు మరియు శ్రేణుల సహాయంతో, మేము ఈ సంఖ్యలను సిరీస్‌లో రూపొందించవచ్చు. ఫైబొనాక్సీ శ్రేణిని సృష్టించడానికి, సంఖ్యలు పూర్ణాంక డేటా రకంలో ఉండాలని సిఫార్సు చేయబడింది. పంక్తుల సంఖ్య మరియు సీక్వెన్స్ సంఖ్యపై పరిమితులను వర్తింపజేయడం ద్వారా మేము శ్రేణిని లెక్కించవచ్చు.