Fn = Fn-1 + Fn-2
இந்த டுடோரியலில் ஃபைபோனச்சி எண்களின் வரிசையை உருவாக்க பல்வேறு வழிமுறைகள் இருக்கும்.
எடுத்துக்காட்டு 1
இந்த எடுத்துக்காட்டில், முதலில், சின் மற்றும் கவுட் ஸ்ட்ரீம்களை இயக்க உள்ளீடு மற்றும் வெளியீட்டு ஸ்ட்ரீம்களின் நூலகம் பயன்படுத்தப்படுகிறது, மேலும் இந்த நூலகத்தின் மூலம் பயனரின் ஈடுபாடும் ஊக்குவிக்கப்படுகிறது. பிரதான நிரலின் உள்ளே, இரண்டு முழு எண் வகை மாறிகளை எடுத்து அவற்றை பூஜ்ஜிய மதிப்பாக அறிவிப்போம். மற்றொரு அடுத்த கால மாறியும் பயன்படுத்தப்படுகிறது, அது பூஜ்ஜியமாக துவக்கப்பட்டு பின்னர் பயன்படுத்தப்படும். Fibonacci தொடரில் பயனருக்குத் தேவைப்படும் எண்ணை உள்ளிடுமாறு கேட்போம். வேறு வார்த்தைகளில் கூறுவதானால், வெளியீட்டாகக் காட்டப்படும் வரிகளின் எண்ணிக்கை பயனரின் உள்ளீட்டைப் பொறுத்தது. பயனர் உள்ளிடும் குறிப்பிட்ட எண்ணின் விளைவாக, இந்த வரிகளில் பதில் இருக்கும்.
வரிசையைக் கணக்கிட பயனர் உள்ளிடும் குறிப்பிட்ட எண்ணை மீண்டும் மீண்டும் செய்ய நமக்கு ஒரு 'for' லூப் தேவை. இது பல வரிகளால் ஒரு வகையான வரம்பு. எண்ணைச் சரிபார்க்க if அறிக்கை பயன்படுத்தப்படுகிறது; அது ஒன்று என்றால், எந்த மாற்றமும் இல்லாமல் அதை அப்படியே காட்டவும். இதேபோல், இரண்டாவது எண்ணும் காட்டப்படும். Fibonacci வரிசையில், முதல் இரண்டு எண்கள் காட்டப்படும். தொடர, தொடர் அறிக்கையைப் பயன்படுத்தியுள்ளோம். தொடரை மேலும் கணக்கிட, இரண்டு மதிப்புகளையும் சேர்ப்போம். மேலும் இது தொடரின் மூன்றாவது எண்ணாக இருக்கும். மாற்றுதல் செயல்முறை தொடங்கிய பிறகு, முதல் மாறிக்கு இரண்டாவது மாறியின் மதிப்பு ஒதுக்கப்படும், மேலும் இரண்டாவது மாறி அடுத்த கால மாறியில் சேமிக்கப்பட்ட மூன்றாவது மதிப்பைக் கொண்டிருக்கும்.
Nextterm = t1 + t2;
T1 = t2;
T2 = அடுத்தது;
இப்போது ஒவ்வொரு மதிப்பும் காற்புள்ளிகளால் பிரிக்கப்பட்டு காட்டப்படும். ஒரு கம்பைலர் மூலம் குறியீட்டை இயக்கவும். உள்ளீட்டு கோப்பில் உள்ள குறியீட்டின் வெளியீட்டைச் சேமிக்க ‘-o’ பயன்படுத்தப்படுகிறது.
$ g++ -ஓ fib fib.c$ / fib
நிரல் செயல்படுத்தப்படும் போது, பயனர் 7 ஐ உள்ளிட்ட எண்ணை உள்ளிடச் சொல்வதை நீங்கள் காணலாம், அதன் விளைவாக 7 வரிகள் இருக்கும், எந்த கட்டத்தில் Fibonacci தொடர் 7 வது புள்ளியை அடைந்தாலும் பரவாயில்லை.
எடுத்துக்காட்டு 2
இந்த எடுத்துக்காட்டில் அடுத்த கால மதிப்பைக் கட்டுப்படுத்துவதன் மூலம் ஃபைபோனச்சி தொடரின் கணக்கீடு இருக்கும். இதன் பொருள் நீங்கள் விரும்பும் அளவுக்கு குறிப்பிட்ட எண்ணை வழங்குவதன் மூலம் Fibonacci தொடரை தனிப்பயனாக்கலாம். முந்தைய உதாரணத்தைப் போலன்றி, முடிவு வரிகளின் எண்ணிக்கையைப் பொறுத்தது அல்ல, ஆனால் ஒரு எண்ணால் கொடுக்கப்பட்ட தொடர்களின் எண்ணிக்கையைப் பொறுத்தது. நாம் முக்கிய நிரலிலிருந்து தொடங்குவோம், மாறிகள் ஒரே மாதிரியானவை, மேலும் பயனர் ஈடுபாட்டின் அணுகுமுறையும் அதேதான். எனவே இரண்டு முதல் மாறிகள் தொடக்கத்தில் பூஜ்ஜியமாக துவக்கப்படும், அடுத்த கால மாறி பூஜ்ஜியமாக அறிவிக்கப்படும். பின்னர் பயனர் எண்ணை உள்ளிடுவார். முதல் இரண்டு சொற்கள் எப்போதும் 0 மற்றும் 1 ஆகக் காட்டப்படும்.
முதல் இரண்டு மாறிகளில் உள்ள எண்களைச் சேர்ப்பதன் மூலம் பெறப்பட்ட மதிப்பு அடுத்த கால மதிப்பு ஒதுக்கப்படும். அடுத்த கால மாறியில் உள்ள மதிப்பு பயனர் கொடுக்கும் எண்ணுக்கு சமமாகவோ அல்லது குறைவாகவோ இருக்கும் வரை தொடரை உருவாக்கும் நிபந்தனையைப் பயன்படுத்த இங்கே a while loop பயன்படுத்தப்படுகிறது.
போது (அடுத்த <= n)
இந்த வளைவின் உள்ளே, பின்தங்கிய திசையில் எண்களை மாற்றுவதன் மூலம் தர்க்கம் பயன்படுத்தப்படும். அடுத்த கால மாறி மீண்டும் மாறிகளின் மதிப்புகளைச் சேர்க்கும்.
Nextterm = t1 + t2;
இப்போது கோப்பைச் சேமித்து, டெர்மினலில் உள்ள குறியீட்டை இயக்க தொகுக்கவும்.
நீங்கள் குறியீட்டை இயக்கும்போது, கணினி உங்களிடமிருந்து ஒரு எண்ணைக் கோரும், அது நேர்மறை எண்ணாக இருக்க வேண்டும். கணக்கீட்டில், 55 வது எண் வரையிலான எண்களின் வரிசை காட்டப்படுவதை நீங்கள் காண்பீர்கள்.
எடுத்துக்காட்டு 3
நாம் குறிப்பிடும் இந்த மூலக் குறியீடு, Fibonacci தொடரைக் கணக்கிடுவதற்கான வேறுபட்ட முறையைக் கொண்டிருக்கும். இப்போது வரை, பிரதான நிரலுக்குள் தொடரைக் கணக்கிட்டுள்ளோம். இந்த எடுத்துக்காட்டு எண்களின் இந்த வரிசையைக் கணக்கிட ஒரு தனி செயல்பாட்டின் ஈடுபாட்டைப் பயன்படுத்துகிறது. செயல்பாட்டின் உள்ளே, செயல்முறையைத் தொடர ஒரு சுழல்நிலை அழைப்பு செய்யப்படுகிறது. எனவே இது மறுநிகழ்வுக்கான உதாரணமும் கூட. செயல்பாடு அளவுருவில் உள்ள எண்ணை எடுக்கும், இது வரை தொடரைக் கணக்கிட வேண்டும். இந்த எண் பிரதான திட்டத்திலிருந்து அனுப்பப்பட்டது. எண் 1 ஐ விடச் சிறியதா அல்லது அதற்கு சமமானதா என்பதைச் சரிபார்க்க if அறிக்கை பயன்படுத்தப்படுகிறது, பின்னர் தொடரைக் கணக்கிடுவதற்கு குறைந்தபட்சம் இரண்டு எண்கள் தேவைப்படுவதால் எண்ணையே திருப்பித் தரவும். இரண்டாவது வழக்கில், நிபந்தனை தவறானது மற்றும் எண் 1 ஐ விட அதிகமாக இருக்கும் போது, செயல்பாட்டிற்கு மீண்டும் மீண்டும் ஒரு சுழல்நிலை அழைப்பைப் பயன்படுத்தி தொடரைக் கணக்கிடுங்கள்.
Fib (n-1) + fib (n-2);
முதல் பகுதியில், மொத்த எண் செயல்பாட்டிற்கு அனுப்பப்படுவதற்கு முன் ஒரு எண், அந்த மதிப்பு மொத்த எண்ணுக்கு முந்தைய இரண்டு எண்களைக் கொண்ட கலத்திலிருந்து பெறப்பட்ட எண்ணிலிருந்து ஒரு அளவுருவாகக் கழிக்கப்படும் என்பதைக் காட்டுகிறது.
இப்போது முக்கிய நிரலில், எண் மாறிக்கு ஒதுக்கப்பட்டுள்ளது, மேலும் செயல்பாட்டிற்கு எண்ணை அனுப்ப முதல் செயல்பாட்டு அழைப்பு செய்யப்படுகிறது. இப்போது பதிலைப் பெற டெர்மினலில் கோப்பின் மூலக் குறியீட்டை இயக்கவும். உள்ளிடப்பட்ட எண் 7 ஆக இருந்ததால், ’13’ என்பது பதில் என்பதை இங்கே பார்க்கலாம், எனவே தொடர் 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 என அறிவிக்கப்படுகின்றன.
அதன் பிறகு, ஃபைபோனச்சி தொடர் கணக்கிடப்படும் 'for' லூப் பயன்படுத்தப்படுகிறது. முந்தைய இரண்டு எண்கள் தொடரில் சேர்க்கப்பட்டு சேமிக்கப்படும்.
F[i] = f[i-1] + f[i -2];
அதன் பிறகு, குறிப்பிட்ட குறியீட்டில் குறிப்பிட்ட எண் திரும்பும்.
பொருளைப் பயன்படுத்தி ஒரு செயல்பாட்டு அழைப்பு செய்யப்படுகிறது.
g.fib(n);
இப்போது குறியீட்டை இயக்கவும், எண் 11 ஆக இருப்பதால், வரிசை 11 வது இலக்கம் வரை இருக்கும்.
முடிவுரை
இந்தக் கட்டுரை 'Fibonacci sequence C++' என்பது முந்தைய இரண்டு எண்களைச் சேர்த்து ஒரு வரிசையை உருவாக்கப் பயன்படுத்தப்படும் வெவ்வேறு அணுகுமுறைகளின் கலவையாகும். ஒரு எளிய ஸ்வாப்பிங் நுட்பத்துடன், மறுநிகழ்வு முறை மற்றும் வரிசைகளின் உதவியுடன், இந்த எண்களை தொடரில் உருவாக்கலாம். Fibonacci தொடரை உருவாக்க, எண்கள் முழு எண் தரவு வகையாக இருக்க பரிந்துரைக்கப்படுகிறது. வரிகளின் எண்ணிக்கை மற்றும் வரிசையின் எண்ணிக்கையில் வரம்புகளைப் பயன்படுத்துவதன் மூலம் தொடரைக் கணக்கிடலாம்.