C++లో, ప్రదర్శించడానికి అనేక పద్ధతులు ఉన్నాయి ఫైబొనాక్సీ సిరీస్ , మరియు ఈ గైడ్ ఈ విధానాల గురించి వివరణాత్మక చర్చను అందిస్తుంది.
C++లో ఫైబొనాక్సీ సిరీస్‌ను ఎలా ప్రదర్శించాలి
C++లో, ఫైబొనాక్సీ సిరీస్‌ను ప్రదర్శించడానికి రెండు పద్ధతులు ఉన్నాయి, అవి క్రింది విధంగా ఉన్నాయి:
విధానం 1: C++లో లూప్ కోసం ఫైబొనాక్సీ సిరీస్‌ని ప్రదర్శించండి
ప్రదర్శించడానికి ఒక మార్గం ఫైబొనాక్సీ సిరీస్ C++లో aని ఉపయోగించాలి లూప్ కోసం . ఈ పద్ధతిలో సిరీస్‌లోని మొదటి రెండు సంఖ్యలను ప్రారంభించడం, ఆపై సిరీస్‌లోని మిగిలిన సంఖ్యలను లెక్కించడానికి మరియు ప్రదర్శించడానికి ఫర్ లూప్‌ని ఉపయోగించడం:
ప్రాతినిధ్యం వహించడానికి దశల వారీ విధానం ఇక్కడ ఉంది ఫైబొనాక్సీ సిరీస్ a ఉపయోగించి లూప్ కోసం C++లో:
దశ 1: iostream వంటి ఇన్‌పుట్/అవుట్‌పుట్ కార్యకలాపాలకు అవసరమైన హెడర్ ఫైల్‌లను జోడించడం ద్వారా ప్రారంభించండి.
దశ 2: సిరీస్ యొక్క మొదటి రెండు పదాల (0 మరియు 1), అలాగే ప్రస్తుత మరియు మునుపటి నిబంధనల విలువలను కలిగి ఉండటానికి అవసరమైన వేరియబుల్‌లను ప్రకటించండి మరియు ప్రారంభించండి.
దశ 3: వారు సిరీస్‌లో ప్రదర్శించాలనుకుంటున్న మొత్తం సంఖ్యలను నమోదు చేయమని వినియోగదారుని ప్రాంప్ట్ చేయండి.
దశ 4: వినియోగదారు ఇన్‌పుట్‌ను చదవండి మరియు దానిని వేరియబుల్‌లో సేవ్ చేయండి.
దశ 5: సిరీస్ యొక్క మొదటి పదాన్ని ఇలా ప్రింట్ చేయండి 0 మరియు సిరీస్ యొక్క రెండవ పదం 1 .
దశ 6: సిరీస్‌లోని మిగిలిన నిబంధనల ద్వారా ప్రాసెస్ చేయడానికి, లూప్ కోసం a ఉపయోగించండి, ప్రతి పదాన్ని మునుపటి రెండు పదాల మొత్తంగా లెక్కించి, తదనుగుణంగా మునుపటి మరియు ప్రస్తుత నిబంధనల విలువలను నవీకరించండి.
దశ 7: లూప్‌లో ప్రస్తుత పదం విలువను ముద్రించండి.
దశ 8: లూప్ అన్ని నిబంధనల ద్వారా పునరావృతం అయినప్పుడు, ప్రోగ్రామ్‌ను ముగించడానికి దాన్ని వదిలివేసి, 0ని తిరిగి ఇవ్వండి.
కింది ఉదాహరణ కోడ్ పై ప్రక్రియను వివరిస్తుంది:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
int a = 0 , బి = 1 , c, i, సంఖ్య ;
కోట్ << 'మూలకాల సంఖ్యను నమోదు చేయండి:' ;
ఆహారపు >> సంఖ్య ;
కోట్ << a << '' << బి << '' ;
కోసం ( i = 2 ; i < సంఖ్య ; ++ i )
{
సి = a + బి ;
కోట్ << సి << '' ;
a = బి ;
బి = సి ;
}
తిరిగి 0 ;
}
పై C++ ప్రోగ్రామ్ ప్రింట్ ది ఫైబొనాక్సీ సిరీస్ వినియోగదారు పేర్కొన్న నిబంధనల సంఖ్య వరకు. ప్రదర్శించాల్సిన నిబంధనల సంఖ్యను నిర్ణయించడానికి ప్రోగ్రామ్ మొదట వినియోగదారు నుండి ఇన్‌పుట్ తీసుకుంటుంది. అప్పుడు, ఇది a ని ఉపయోగిస్తుంది లూప్ కోసం సిరీస్‌ను రూపొందించడానికి మరియు ముద్రించడానికి, మొదటి రెండు సంఖ్యలు 0 మరియు 1తో మొదలవుతాయి. ఇది కావలసిన పదాల సంఖ్యను చేరుకునే వరకు మునుపటి రెండు సంఖ్యల మొత్తాన్ని లెక్కించడం మరియు ముద్రించడం కొనసాగిస్తుంది.
అవుట్‌పుట్
విధానం 2: C++లో రికర్షన్‌తో ఫిబొనాక్సీ సిరీస్‌ని ప్రదర్శించండి
పునరావృతం ప్రాతినిధ్యం వహించడానికి మరొక విధానం ఫైబొనాక్సీ సిరీస్ C++లో. ఈ పద్ధతిలో a సృష్టించడం ఉంటుంది పునరావృత ఫంక్షన్ ఇది నిబంధనల సంఖ్యను ఇన్‌పుట్‌గా అంగీకరించి, ఆపై ఉపయోగిస్తుంది పునరావృతం లెక్కించేందుకు మరియు చూపించడానికి ఫైబొనాక్సీ సిరీస్ .
ప్రాతినిధ్యం వహించడానికి దశల వారీ విధానం ఇక్కడ ఉంది ఫైబొనాక్సీ సిరీస్ ఉపయోగించి పునరావృతం C++లో:
దశ 1: గణించడానికి పునరావృత ఫంక్షన్‌ను సృష్టించడం ద్వారా ప్రారంభించండి ఫైబొనాక్సీ సిరీస్ .
దశ 2: సిరీస్‌లోని పదాల సంఖ్యను ఆర్గ్యుమెంట్‌గా ఫంక్షన్‌కు పంపాలి.
దశ 3: ఇన్‌పుట్ 0 లేదా 1 అయితే ఫంక్షన్ సిరీస్‌లో సంబంధిత సంఖ్యను తిరిగి ఇచ్చే ఫంక్షన్ కోసం బేస్ కేస్‌ను నిర్వచించండి.
దశ 4: సిరీస్‌లోని మునుపటి రెండు పదాలను ఉపయోగించి పునరావృతంగా ఫంక్షన్‌కు కాల్ చేయండి మరియు ఏదైనా ఇతర ఇన్‌పుట్ కోసం ప్రస్తుత పదాన్ని పొందడానికి వాటిని కలిపి జోడించండి.
దశ 5: ఫంక్షన్ అవుట్‌పుట్‌గా, ప్రస్తుత పదాన్ని తిరిగి ఇవ్వండి.
దశ 6: ప్రధాన ఫంక్షన్‌లో, సిరీస్‌లో ఎన్ని నిబంధనలను వీక్షించాలనుకుంటున్నారో వినియోగదారుని అడగండి.
దశ 7: వినియోగదారు అందించిన సంఖ్య వరకు ప్రతి పదం కోసం, పునరావృత ఫైబొనాక్సీ ఫంక్షన్‌కు కాల్ చేసి, ఫలితాన్ని ముద్రించండి.
కింది కోడ్ పై ప్రక్రియను వివరిస్తుంది:
#includeఉపయోగించి నేమ్‌స్పేస్ std ;
int fib ( int n ) {
ఉంటే ( n <= 1 )
తిరిగి n ;
తిరిగి fib ( n - 1 ) + fib ( n - 2 ) ;
}
int ప్రధాన ( ) {
కోట్ << 'ఫైబొనాక్సీ సిరీస్ యొక్క అవుట్‌పుట్: \n ' ;
int n = 23 , ఐ ;
కోసం ( i = 0 ; i < n ; i ++ )
కోట్ << fib ( i ) << '' ;
తిరిగి 0 ;
}
ది ఫైబొనాక్సీ సిరీస్ ఉపయోగించి లెక్కించబడుతుంది మరియు ప్రదర్శించబడుతుంది పునరావృతం పై C++ ప్రోగ్రామ్‌లో 23వ టర్మ్ వరకు. ఇది నిర్దేశిస్తుంది fib ఫంక్షన్, ఇది పూర్ణాంకాన్ని తీసుకుంటుంది n ఇన్‌పుట్‌గా మరియు పునరావృతంగా గణిస్తుంది మరియు n-వ పదాన్ని అందిస్తుంది ఫైబొనాక్సీ సీక్వెన్స్ ఫార్ములా ఉపయోగించి F(n) = F(n-1) + F(n-2) బేస్ కేసులతో F(0) = 0 మరియు F(1) = 1 . ప్రధాన ఫంక్షన్ అప్పుడు కాల్ చేస్తుంది fib ప్రతి పదం కోసం n సార్లు వరకు పని చేస్తుంది మరియు ఫలితాన్ని కన్సోల్‌కు ప్రింట్ చేస్తుంది.
అవుట్‌పుట్
క్రింది గీత
ది ఫైబొనాక్సీ సిరీస్ C++లో ప్రతి సంఖ్య మునుపటి రెండు పదాల మొత్తానికి సమానంగా ఉండే సంఖ్యల సమితి. ప్రదర్శించడానికి రెండు మార్గాలు ఉన్నాయి ఫైబొనాక్సీ సిరీస్ C++లో, ఒకటి ద్వారా లూప్ కోసం మరియు మరొకటి ద్వారా పునరావృతం . ప్రోగ్రామర్లు అమలు చేయడానికి ఏ మార్గాన్ని అయినా ఉపయోగించవచ్చు ఫైబొనాక్సీ సీక్వెన్స్ అప్లికేషన్ల శ్రేణి కోసం వారి C++ ప్రోగ్రామ్‌లలో.