ተደጋጋሚነት በተደራሽ ቋንቋ። መደጋገም. የስልጠና ተግባራት

ቫርግ እንዲህ ይላል:

ደህና ከሰአት, ይህ ተግባር እንዴት ስሌቶችን እንደሚያከናውን በትክክል መረዳት አልችልም.

{
(n==1) ከተመለሰ 1; // አዲሱ ዋጋ 1 ከሆነ, ከዚያ ከ 1 ጋር እንጨምራለን, እና ከቀዳሚው ጋር አይደለም. ምክንያቱም ቀዳሚው ዜሮ ነው። እና መደመር 1+0 ማለቂያ የሌለው ይሆናል።
ያለበለዚያ ድምር (n-1)+n መመለስ; // ግን n>1 ከሆነ፣ ከዚያ እስከ n ድረስ ካለው የሁሉም ንጥረ ነገሮች ድምር ጋር እኩል ከሆነው ከቀደመው እሴት ጋር ይጨምሩ
}

በእኔ ግንዛቤ, በ n ውስጥ 5, ሁኔታው አይመሳሰልም ከዚያም ይረካል ይህ ኮድድምር(n-1)+n ማለትም በቅንፍ ውስጥ በመቀነስ የተገኘ ነገር ወደ 5 ተጨምሯል ነገር ግን (5 - 1)+5 ምንድን ነው እና ከሆነስ ይህን የሂሳብ አሰራር የሚያቆመው ምንድን ነው:: የቀደመ አንድ እሴት ምንድን ነው ፣ ከየት ነው የመጣው ፣ ምን እኩል ነው?

አዎ ፣ ሁሉም ነገር ማለት ይቻላል እኔ እንደተረዳሁት ነው (በመጨረሻው አንቀፅ ውስጥ ድግግሞሽ አሳይተዋል)) ፣ ግን ጥያቄው ይቀራል - ድምር እንዴት ተገኝቷል ፣ ከዚያ በስክሪኑ ላይ የሚታየው?
ለኔ ከDev C++ ጋር እየሰራሁ ነው። ይህ ምሳሌመጠኑን ==15 ያሳያል፣ በምሳሌው ላይ እንደተፃፈው ከቆጠሩ፣ መጠኑ የተለየ ይሆናል።
ከላይ ጽፌ ነበር፣ (5-1)+5=4+5=9 እንውሰድ

:
1+2+3+4+5 = 15. ምሳሌው በትክክል ይወጣል.

(5) // ለተግባሩ 5 ሰጠን, ከአንድ ጋር እኩልነትን አረጋግጧል. እኩል አይደለም, ተግባሩን እንደገና ይባላል, 5-1 ወደ ውስጥ በማለፍ
(5-1+(5)) //...
(4-1+(5-1+(5)))
(3-1+(4-1+(5-1+(5))))
(2-1+(3-1+(4-1+(5-1+(5)))))

2-1 == 1፣ ተግባሩን መጥራት ጨርሷል።
(2-1+(3-1+(4-1+(5-1+(5))))) == 15
ይህ ነው ውጤቱ።
እዚህ የተግባሩ ውጤት የመጀመሪያዎቹ ሁለት ቁጥሮች ልዩነት ነው, እና n የቀረው የቀኝ ጎን ነው
__________________________________
ተግባሩን በትክክል መረዳት እና እንደ ስሌት እሴት መቀበል እና እንደ ተለዋዋጭ አለመረዳት ብቻ ያስፈልግዎታል። እሱ ከተለዋዋጭ ጋር ተመሳሳይ ነው ፣ ግን ወደ ስሌት ቋሚ ቅርብ ነው ፣ ምንም እንኳን ቋሚ ባይሆንም ፣ በቀላሉ በዚህ መንገድ ለመረዳት የበለጠ ምቹ ነው።

አዎ, አዎ, አዎ, የተረዳሁትን ለመጻፍ ጊዜ አላገኘሁም, ሁሉም ነገር ትክክል ነው, የሆነ ነገር ወዲያውኑ አላለፈም. እናመሰግናለን ጥሩ ጣቢያ))

እና አሁንም በ 8 ኛው መስመር ውስጥ ሙሉ በሙሉ ምክንያታዊ አይደለም የተመለሰውን ቁጥር ከ 1 ወደ 2 መመለሻ ከቀየሩ, መጠኑ ወደ 16 ይቀየራል. ይህ ሁኔታ ከ 9 ኛው መስመር ጋር እንዴት ይዛመዳል?
ከዚህ ጋር, እንደዚሁም, ሁሉም ነገር ግልጽ ነው, መመለስ ብቻ 2 እጦቱን ወደ ድምር ይጨምራል, ለመናገር.

:
ተጨማሪው ኮከብ ሳይሆን እነዚህ ሁለት እና -3 ከፃፉ አንድ ጊዜ ሲደመር ሦስቱን ይቀንሳል, ወዘተ.
አጠቃላይ አመክንዮ ማንኛውም ተደጋጋሚ ተግባር የመመለሻ ነጥብ ያስፈልገዋል።
ከዘጠነኛው መስመር ጋር ያለው ግንኙነት አንድ ቁጥር ከውስጥ ዋናው ሲጠራ ወደ ድምር ተግባር ይተላለፋል, ይህ ቁጥር በያንዳንዱ ጊዜ በአንድ (n-1) ይቀንሳል, ይህ ውጤት n-1 ምልክት ይደረግበታል. ከአንዱ ጋር እኩልነት እና እኩልነት እውነት ከሆነ፣ የተቀበለው ገንዘብ በሙሉ በዚያ ተመላሽ ውስጥ ካለው ቁጥር ጋር ይጠቃለል። አለበለዚያ አጠቃላይ ድምር በዚህ አዲስ n-1 ይጠቃለላል

ተደጋጋሚነት በሳይንስ መስክ ብቻ ሳይሆን በ ውስጥም የሚከሰት በጣም የተለመደ ክስተት ነው። የዕለት ተዕለት ኑሮ. ለምሳሌ፣ Droste effect፣ Sierpinski triangle፣ ወዘተ. በጣም ቀላሉ መንገድ ተደጋጋሚነትን ለማየት የዌብ ካሜራውን በኮምፒዩተር መከታተያ ስክሪን ላይ ማመላከት ነው፣ በተፈጥሮ፣ በመጀመሪያ በማብራት። ስለዚህ, ካሜራው የኮምፒዩተር ስክሪን ምስልን ይመዘግባል እና በዚህ ስክሪን ላይ ያሳየዋል, ልክ እንደ ዝግ ዑደት ያለ ነገር ይሆናል. በውጤቱም, ከዋሻው ጋር ተመሳሳይ የሆነ ነገር እናስተውላለን.

በፕሮግራም አወጣጥ ውስጥ ፣ ድግግሞሽ ከተግባሮች ጋር በቅርበት ይዛመዳል ፣ በፕሮግራም አወጣጥ ውስጥ እንደዚህ ያለ ነገር አለ ማለት ነው ተደጋጋሚ ተግባር. በቀላል ቃላት, ተደጋጋሚነት የአንድ ተግባር (ዘዴ) አካል በራሱ ፍቺ ነው፣ ማለትም እሱ ራሱ በቀጥታ (በአካሉ ውስጥ) ወይም በተዘዋዋሪ (በሌላ ተግባር) የሚጠራ ተግባር ነው። የተለመደ ተደጋጋሚ ችግሮችተግባራቶቹ ናቸው: ማግኘት n!, Fibonacci ቁጥሮች. እንደነዚህ ያሉ ችግሮችን አስቀድመን ፈትተናል, ግን loops በመጠቀም, ማለትም, በተደጋጋሚ. በጥቅሉ አነጋገር፣ በድግግሞሽ የሚፈታው ነገር ሁሉ በተደጋጋሚ ሊፈታ ይችላል፣ ማለትም፣ ተደጋጋሚ ተግባርን በመጠቀም። ጠቅላላው መፍትሄ የሚመጣው ዋናውን ወይም እንደ መሰረቱን ጉዳይ ለመፍታት ነው. እንደ ድግግሞሽ እርምጃ ወይም ተደጋጋሚ ጥሪ ያለ ነገር አለ። ውስብስብ ችግርን ለመፍታት ተደጋጋሚ ተግባር በተጠራበት ሁኔታ (የመሠረቱ ጉዳይ አይደለም) ፣ የተወሰነ ቁጥር ተደጋጋሚ ጥሪዎችወይም አንድን ተግባር ወደ ቀላል ለመቀነስ እርምጃዎች። እና እኛ እስክንደርስ ድረስ መሠረታዊ መፍትሔ. n ያሰላል ተደጋጋሚ ተግባር የሚያውጅ ፕሮግራም እናዳብር!

"stdafx.h" #ያካትቱ << "Enter n!: "; cin >> n;<< n << "!" << "=" << factorial(n) << endl; // вызов рекурсивной функции system("pause"); return 0; } unsigned long int factorial(unsigned long int f) // рекурсивная функция для нахождения n! { if (f == 1 || f == 0) // базовое или частное решение return 1; // все мы знаем, что 1!=1 и 0!=1 cout << "Step\t" << i << endl; i++; // операция инкремента шага рекурсивных вызовов cout << "Result= " << result << endl; result = f * factorial(f - 1); // функция вызывает саму себя, причём её аргумент уже на 1 меньше return result; }

ኮት

// ኮድ ኮድ :: ያግዳል

// Dev-C ++ ኮድ የስም ቦታ std በመጠቀም; ያልተፈረመ ረጅም int ፋብሪካ (ያልተፈረመ ረጅም int); // ተደጋጋሚ ጥሪዎችን ቁጥር ለመቁጠር ዓለም አቀፋዊ ተለዋዋጭን ማስጀመር ያልተፈረመ ረጅም int ውጤት; // የተመለሰውን የሪከርሲቭ ተግባር int ዋና (int argc, char* argv) (int n; // የገባውን ቁጥር ከቁልፍ ሰሌዳው ለማለፍ አካባቢያዊ ተለዋዋጭ) የተመለሰውን ውጤት ለማከማቸት ዓለም አቀፍ ተለዋዋጭ<< "Enter n!: "; cin >> n;<< n << "!" << "=" << factorial(n) << endl; // вызов рекурсивной функции return 0; } unsigned long int factorial(unsigned long int f) // рекурсивная функция для нахождения n! { if (f == 1 || f == 0) // базовое или частное решение return 1; // все мы знаем, что 1!=1 и 0!=1 cout << "Step\t" << i << endl; i++; // операция инкремента шага рекурсивных вызовов cout << "Result= " << result << endl; result = f * factorial(f - 1); // функция вызывает саму себя, причём её аргумент уже на 1 меньше return result; }

ውስጥ መስመር 7፣9፣21የመረጃው አይነት ሳይፈረም ታውጇል ረጅም int , የፋብሪካው ዋጋ በጣም በፍጥነት ስለሚጨምር ለምሳሌ ቀድሞውኑ 10! = 3,628,800 የውሂብ አይነት መጠን በቂ ካልሆነ, ውጤቱ ሙሉ በሙሉ የተሳሳተ እሴት ይሆናል. ኮዱ n ለማግኘት ከሚያስፈልገው በላይ ኦፕሬተሮችን ያውጃል። ይህ የሚደረገው ከሩጫ በኋላ ፕሮግራሙ በእያንዳንዱ የድግግሞሽ ጥሪዎች ደረጃ ምን እንደሚከሰት ያሳያል። እባክዎ የደመቁትን የኮድ መስመሮችን ያስተውሉ፣ መስመር 23፣24፣28ለ n ተደጋጋሚ መፍትሄ ነው! መስመር 23፣24የተደጋጋሚነት ተግባር መሰረታዊ መፍትሄዎች ናቸው, ማለትም, በተለዋዋጭ ውስጥ ያለው ዋጋ ልክ እንደ ረከ 1 ወይም 0 ጋር እኩል ይሆናል (1! = 1 እና 0! = 1 ስለምናውቅ), ተደጋጋሚ ጥሪዎች ይቆማሉ, እና እሴቶቹ ለእያንዳንዱ ተደጋጋሚ ጥሪ መመለስ ይጀምራሉ. ለመጀመሪያው ተደጋጋሚ ጥሪ ዋጋ ሲመለስ ፕሮግራሙ የተሰላውን ፋክተር ዋጋ ይመልሳል። ውስጥ መስመር 28ፋክተሪያል () ተግባር እራሱን ይጠራል, ግን ክርክሩ አንድ ያነሰ ነው. አንድ የተወሰነ መፍትሄ ለመድረስ ክርክሩ በእያንዳንዱ ጊዜ ይቀንሳል. የፕሮግራሙ ውጤት (ስእል 1 ይመልከቱ).

አስገባ n!፡ 5 ደረጃ 1 ውጤት= 0 ደረጃ 2 ውጤት= 0 ደረጃ 3 ውጤት= 0 ደረጃ 4 ውጤት= 0 5!=120

ምስል 1 - በ C ++ ውስጥ ድግግሞሽ

በፕሮግራሙ ውጤት ላይ በመመርኮዝ እያንዳንዱ እርምጃ በግልጽ የሚታይ ሲሆን በእያንዳንዱ ደረጃ ላይ ያለው ውጤት ዜሮ ነው, ከመጨረሻው ተደጋጋሚ ጥሪ በስተቀር. አምስት ፋብሪካዎችን ማስላት አስፈላጊ ነበር. ፕሮግራሙ አራት ተደጋጋሚ ጥሪዎችን አድርጓል, እና በአምስተኛው ጥሪ ላይ የመሠረት መያዣው ተገኝቷል. እና ፕሮግራሙ ለመሠረታዊ ጉዳይ መፍትሄ ካገኘ በኋላ, የቀደሙትን እርምጃዎች ፈትቶ አጠቃላይ ውጤቱን አወጣ. በስእል 1 ውስጥ አራት ደረጃዎች ብቻ ናቸው የሚታዩት ምክንያቱም በአምስተኛው ደረጃ ከፊል መፍትሄ ተገኝቷል, በመጨረሻም የመጨረሻውን መፍትሄ መለሰ, ማለትም 120. ምስል 2 የእንደገና ስሌት እቅድ 5 ያሳያል. ስዕሉ በግልጽ እንደሚያሳየው የመጀመሪያው ውጤት አንድ የተወሰነ መፍትሄ ሲደርስ ይመለሳል, ነገር ግን ከእያንዳንዱ ተደጋጋሚ ጥሪ በኋላ ወዲያውኑ አይደለም.

ምስል 2 - በ C ++ ውስጥ ድግግሞሽ

ስለዚህ 5 ለማግኘት! ማወቅ ያስፈልጋል 4! እና በ 5 ያባዙት; 4! = 4 * 3! ወዘተ. በስእል 2 ላይ በሚታየው ሥዕላዊ መግለጫ መሠረት ስሌቱ ልዩ ሁኔታን ለማግኘት ማለትም 1!, ከዚያ በኋላ ዋጋዎች ወደ እያንዳንዱ ተደጋጋሚ ጥሪ ይመለሳሉ. የመጨረሻው ተደጋጋሚ ጥሪ እሴቱን 5 ይመልሳል!

የፋብሪካዎችን ሰንጠረዥ ለማግኘት ፋብሪካውን ለማግኘት ፕሮግራሙን እንደገና እንሥራ። ይህንን ለማድረግ, የድግግሞሹን ተግባር የምንጠራበት ለ loop እናውጃለን.

የስም ቦታ std በመጠቀም; ያልተፈረመ ረጅም int ፋብሪካ (ያልተፈረመ ረጅም int); // ተደጋጋሚ ጥሪዎችን ቁጥር ለመቁጠር ዓለም አቀፋዊ ተለዋዋጭን ማስጀመር ያልተፈረመ ረጅም int ውጤት; // የተመለሰውን የሪከርሲቭ ተግባር int ዋና (int argc, char* argv) (int n; // የገባውን ቁጥር ከቁልፍ ሰሌዳው ለማለፍ አካባቢያዊ ተለዋዋጭ) የተመለሰውን ውጤት ለማከማቸት ዓለም አቀፍ ተለዋዋጭ<< "Enter n!: "; cin >> n;<= n; k++) { cout << k << "!" << "=" << factorial(k) << endl; // вызов рекурсивной функции } system("pause"); return 0; } unsigned long int factorial(unsigned long int f) // рекурсивная функция для нахождения n! { if (f == 1 || f == 0) // базовое или частное решение return 1; // все мы знаем, что 1!=1 и 0!=1 //cout << "Step\t"<< i <> n;<= n; k++) { cout << k << "!" << "=" << factorial(k) << endl; // вызов рекурсивной функции } return 0; } unsigned long int factorial(unsigned long int f) // рекурсивная функция для нахождения n! { if (f == 1 || f == 0) // базовое или частное решение return 1; // все мы знаем, что 1!=1 и 0!=1 //cout << "Step\t"<< i <> <= entered_number; counter++) cout << setw(2) <

ኮት

// ኮድ ኮድ :: ያግዳል

// fibonacci.cpp፡ ለኮንሶል አፕሊኬሽኑ የመግቢያ ነጥቡን ይገልጻል። "stdafx.h" #ያካትቱ // fibonacci.cpp፡ ለኮንሶል አፕሊኬሽኑ የመግቢያ ነጥቡን ይገልጻል። #ያካትቱ // በስክሪኑ ላይ የሚታየውን መረጃ ለመቅረጽ ቤተ መጻሕፍት # ያካትቱ<< "Enter number from the Fibonacci series: "; cin >የስም ቦታ std በመጠቀም; ያልተፈረመ ረጅም ፋይቦናቺ(ያልተፈረመ ረጅም)፣ ከFibonacci series int main(int argc, char* argv) ቁጥሮችን ለመፈለግ የተደጋጋሚ ተግባር ምሳሌ (ያልተፈረመ ረጅም የገባው_ቁጥር; cout<= entered_number; counter++) cout << setw(2) <#ያካትቱ የስም ቦታ std በመጠቀም; ባዶ ማማ (int, int, int, int); // የአንድ ተደጋጋሚ ተግባር ፕሮቶታይፕ መግለጫ int ቆጠራ = 1; // የአለምአቀፍ ተለዋዋጭ የእርምጃዎች ብዛት ለመቁጠር int _tmain(int argc, _TCHAR* argv) (cout)<< "Enter of numbers of disks: ";// введите количество дисков, которые надо переместить int number; cin >> ቁጥር;<< "Enter the number of basic rod: "; // введите номер стержня, на котором диски будут находится изначально int basic_rod; cin >ኮት<< "Enter the number of final rod: "; // введите номер стержня, на который необходимо переместить диски int final_rod; cin >> መሰረታዊ_ዘንግ;<< setw(2) << count << ") "<< baza << " " << "->" << " " << new_baza << endl; count++; } else { tower(count_disk -1, baza, new_baza, help_baza); // перемещаем все диски кроме самого последнего на вспомогательный стержень tower(1, baza, help_baza, new_baza); // перемещаем последний диск с начального стержня на финальный стержень tower(count_disk -1, help_baza, baza, new_baza); // перемещаем все диски со вспомогательного стержня на финальный } }

ኮት

// ኮድ ኮድ :: ያግዳል

ኮት #ያካትቱ > የመጨረሻ_ሮድ;<< "Enter of numbers of disks: ";// введите количество дисков, которые надо переместить int number; cin >> ቁጥር;<< "Enter the number of basic rod: "; // введите номер стержня, на котором диски будут находится изначально int basic_rod; cin >ኮት<< "Enter the number of final rod: "; // введите номер стержня, на который необходимо переместить диски int final_rod; cin >> የመጨረሻ_ሮድ;<< setw(2) << count << ") "<< baza << " " << "->" << " " << new_baza << endl; count++; } else { tower(count_disk -1, baza, new_baza, help_baza); // перемещаем все диски кроме самого последнего на вспомогательный стержень tower(1, baza, help_baza, new_baza); // перемещаем последний диск с начального стержня на финальный стержень tower(count_disk -1, help_baza, baza, new_baza); // перемещаем все диски со вспомогательного стержня на финальный } }

int help_rod;

// የረዳት በትር ቁጥር ለመወሰን የማገጃ, የመጀመሪያ እና የመጨረሻ በትር ቁጥሮች በመተንተን ከሆነ (መሰረታዊ_rod! = 2 & & final_rod! = 2) help_rod = 2;

ሌላ ከሆነ (መሰረታዊ_rod! = 1 & & final_rod! = 1) help_rod = 1;

ሌላ ከሆነ (መሰረታዊ_rod! = 3 & & final_rod! = 3) help_rod = 3;ግንብ (// የሃኖይ ግንብ ችግርን ለመፍታት ተደጋጋሚ ተግባርን ማስጀመር ፣ // መንቀሳቀስ ያለባቸውን የዲስኮች ብዛት ማከማቸት መሰረታዊ_rod ፣ // ዲስኮች መጀመሪያ ላይ የሚቀመጡበትን ዘንግ ቁጥር የሚያከማች ተለዋዋጭ። የሚገኝ help_rod , // እንደ ረዳት የመጨረሻ_ሮድ ጥቅም ላይ የሚውለውን የዱላውን ቁጥር የሚያከማች ተለዋዋጭ); // ዲስኮች መንቀሳቀስ ያለባቸውን የዱላውን ቁጥር ማከማቸት ተለዋዋጭ መመለስ 0; ባዶ ማማ (int count_disk ፣ int baza ፣ int help_baza ፣ int new_baza) (ከሆነ (የቁጥር_ዲስክ == 1) // ተደጋጋሚ ጥሪዎችን የማቆም ሁኔታ (cout)

ምስል 5 የሃኖይ ግንብ ሪከርሲቭ ፕሮግራም ምሳሌ ያሳያል። በመጀመሪያ, ከሶስት ጋር እኩል የሆነ የዲስክ ቁጥር አስገባን, ከዚያም ወደ መሰረታዊ ዘንግ (መጀመሪያ) አስገባን እና የመጨረሻውን ዘንግ (ሦስተኛውን) ሾመን. በራስ-ሰር ሁለተኛው ዘንግ ረዳት ሆነ. ፕሮግራሙ ለዚህ ችግር ከአኒሜሽን መፍትሄ ጋር ሙሉ በሙሉ የሚስማማ ውጤት አስገኝቷል።

በ C++ ውስጥ ብዙ የመድገም ምሳሌዎች በሚኖሩበት አንድ ትልቅ ጽሑፍ ላለመጻፍ ፣ እዚህ አንድ ተጨማሪ የድግግሞሽ ምሳሌ እጽፋለሁ። በአጠቃላይ, መሰረቱን የተረዱ እና በተግባራቸው ውስጥ ቀጥተኛ ድግግሞሽን የሚጠቀሙ ሰዎች ይህንን ቁሳቁስ መዝለል ይችላሉ. በ C++ ውስጥ ለጀማሪዎች ተግባራት በጽሁፉ ላይ እንደተገለጸው ድግግሞሽን የመጠቀም ምሳሌ እዚህ አለ። መደጋገም

ችግር 1 - ድግግሞሽን በመጠቀም የቁጥር ፋክተርን ከ 1 እስከ ኤን ያሳዩ
ኮድ መጻፍ
=============================
ደረጃ ቁጥር 1 ባዶ ፕሮግራም ይጻፉ
=============================

#ያካትቱ

int ዋና()
{
ስርዓት ("cls");

ጌች ();
መመለስ 0;
}

ባዶ ፕሮግራም ተፈጥሯል, አስተያየት መስጠት አያስፈልግም ብዬ አስባለሁ
ደረጃ ቁጥር 2 እኛ የምንጽፈው የድግግሞሹን ተግባር ራሱ እንጽፋለን
=========================================

#ያካትቱ

//የእኛ ተደጋጋሚ ተግባር
ኢንት እውነታ (int N)
{

//0! = 1፣ 1!=1፣ 2!=2፣ 3!=6... ምክንያቱም የመጀመሪያዎቹ 2 ቁጥሮች አንድ ናቸው እና በጥብቅ ቅደም ተከተል ውስጥ አይደሉም ፣ ይህንን ነጥብ በኮዱ ውስጥ እናስገድዳለን።

n ከሆነ<2 return 1 ;
ሌላ ተመለስ n * እውነታ (n-1) // እዚህ ተግባሩ እራሱን ይጠራል

}

int ዋና()
{
ስርዓት ("cls");
ኮት<// የድግግሞሽ ተግባር ጥሪ ነጥብ. በስክሪኑ ላይ ፋብሪካ 10 በማሳየት ላይ
ጌች ();
መመለስ 0;
}
ዲ.ዲ
============

በ C ++ ተደጋጋሚ ፕሮግራም ውስጥ ዋናው ቁራጭ
መመለስ n * እውነታ (n-1)

የእኛ ተግባር የቀደመውን ዋጋ ለማግኘት እንደገና ይሰላል። ትክክለኛው እሴት የሚተላለፈው መለኪያ ነው። nከተግባር ጥሪው ነጥብ. ተግባራችንን የምንጠራበት ነጥብ ከፕሮግራሙ ዋና ብሎክ መደወል ነው። በእኛ ሁኔታ, ከተግባር እንጠራዋለን int ዋና()
የሚቀጥለውን ሳይሆን የቀደመውን ለምን እጽፋለሁ? ቁጥሮች ሲበዙ በመጀመሪያ 0 * 1 የእኛ የአሁኑ ዋጋ 1 ነው, እና ዜሮ የቀደመ ስሌት ዋጋ ነው. ይህ የመድገም አጠቃላይ ይዘት ነው, የአሁኑን ዋጋ ቀዳሚውን በመጠቀም እናሰላለን, የቀደመው ዋጋ በተመሳሳይ ስሌት ይገኛል. ማጠናቀቂያው ራሱ የቀደመውን ዋጋ ያሰላል እና ይህንን እሴት በማህደረ ትውስታ ውስጥ ያከማቻል። እኛ ማድረግ ያለብን መመሪያ መስጠት ብቻ ነው። . ለዚህ የአቀናባሪዎች ባህሪ ምስጋና ይግባውና አንድ ተግባር እራሱን ለመጥራት መመሪያ ሲያጋጥመው (በእኛ ሁኔታ እውነታ (n-1) ) የተላለፈውን መለኪያ አይደግፍም nተግባሩን ለማስላት. መለኪያው አልፏል nበማስታወስ ውስጥ ይኖራል. በዚህ ሁኔታ, ሌላ የማስታወሻ ቦታ በተጨማሪነት ይገለጻል, ይህም የእኛ ተደጋጋሚ ተግባራቶች የቀደመውን ውጤት ለማግኘት ተደጋጋሚ ስሌቶችን ያከናውናል.

ፕሮግራመሮች ለእንዲህ ያለ የተፋለሰ ፍርድ ይቅር በሉኝ። ጀማሪዎች ተደጋጋሚነትን የሚገነዘቡት ይህ በግምት ነው።

ይህ የC++ ብሎግ ለጀማሪዎች ለአንድ ሰው ጠቃሚ ነበር እናም አንድ ሰው በC++ ውስጥ ያለውን የተደጋጋሚነት ተግባር መሰረታዊ ፅንሰ-ሀሳብ እንዲረዳ እንደረዳው ተስፋ አደርጋለሁ።

ማስታወሻ. በዚህ ጽሑፍ ውስጥ, ልክ እንደ ቀድሞው, ስሌቱን ከ 1 ወደ N ሳይሆን በፕሮግራሙ ውስጥ የገባውን እሴት አደረግሁ. ነጥቡ ተጨማሪ የኮድ መስመር መጻፍ አልፈለኩም እና ተጠቃሚው አስቀድሞ መረጃን በማስገባት እና በማያ ገጹ ላይ ለማሳየት ጠንቅቆ ያውቃል ብዬ አስቤ ነበር.

ሰላም ሀበራብር!

በዚህ ጽሑፍ ውስጥ ስለ ተደጋጋሚ ችግሮች እና እንዴት እንደሚፈቱ እንነጋገራለን.

ስለ ተደጋጋሚነት በአጭሩ

ተደጋጋሚነት በሳይንስ መስክ ብቻ ሳይሆን በዕለት ተዕለት ሕይወት ውስጥ የሚከሰት በጣም የተለመደ ክስተት ነው። ለምሳሌ፣ Droste effect፣ Sierpinski triangle፣ ወዘተ. ተደጋጋሚነትን የምናይበት አንዱ መንገድ ዌብ ካሜራውን በኮምፒዩተር መከታተያ ስክሪን ላይ ማመላከት ነው፣ በተፈጥሮ፣ በመጀመሪያ በማብራት። ስለዚህ, ካሜራው የኮምፒዩተር ስክሪን ምስልን ይመዘግባል እና በዚህ ስክሪን ላይ ያሳየዋል, ልክ እንደ ዝግ ዑደት ያለ ነገር ይሆናል. በውጤቱም, ከዋሻው ጋር ተመሳሳይ የሆነ ነገር እናስተውላለን.

በፕሮግራም አወጣጥ ውስጥ, ድግግሞሽ ከተግባሮች ጋር በቅርበት ይዛመዳል, በፕሮግራም ውስጥ ያሉ ተግባራት ምስጋና ይግባቸውና እንደ ድግግሞሽ ወይም ተደጋጋሚ ተግባር አለ. በቀላል አነጋገር፣ ተደጋጋሚነት የአንድ ተግባር (ዘዴ) አካል በራሱ ፍቺ ነው፣ ማለትም፣ ራሱን የሚጠራ ተግባር ነው፣ በቀጥታ (በአካሉ ውስጥ) ወይም በተዘዋዋሪ (በሌላ ተግባር)።

ስለ ተደጋጋሚነት ብዙ ተብሏል። አንዳንድ ጥሩ ሀብቶች እነኚሁና:

ተደጋጋሚ እና ተደጋጋሚ ችግሮች. የመድገም ትግበራ ቦታዎች

አንባቢው በንድፈ ሃሳቡ ስለ ተደጋጋሚነት ጠንቅቆ ያውቃል እና ምን እንደሆነ ያውቃል ተብሎ ይታሰባል። በዚህ ጽሑፍ ውስጥ ለተደጋጋሚ ችግሮች የበለጠ ትኩረት እንሰጣለን.

ተግባራት

ድግግሞሽን በሚማርበት ጊዜ ተደጋጋሚነትን ለመረዳት በጣም ውጤታማው መንገድ ችግሮችን መፍታት ነው።

የተደጋጋሚነት ችግሮችን እንዴት መፍታት ይቻላል?

በመጀመሪያ ደረጃ, መደጋገም ከመጠን በላይ መጨፍጨፍ አይነት መሆኑን መረዳት ያስፈልግዎታል. በጥቅሉ አነጋገር፣ በድግግሞሽ የሚፈታው ነገር ሁሉ በተደጋጋሚ ሊፈታ ይችላል፣ ማለትም፣ ተደጋጋሚ ተግባርን በመጠቀም።

ከአውታረ መረቡ

በድግግሞሽ መልክ የተተገበረ ማንኛውም አልጎሪዝም በድግግሞሽ መልክ እና በተቃራኒው እንደገና ሊፃፍ ይችላል. ይህ አስፈላጊ መሆኑን እና ምን ያህል ውጤታማ እንደሚሆን ጥያቄው ይቀራል.

ይህንን ለማስረዳት የሚከተሉት መከራከሪያዎች ሊሰጡ ይችላሉ።

ለመጀመር ፣ የመድገም እና የመድገም ትርጓሜዎችን ማስታወስ እንችላለን። ተደጋጋሚነት (Recursion) አንድ ፕሮግራም በቀጥታ ወይም በሌሎች ፕሮግራሞች በመታገዝ ራሱን የሚጠራበት የመረጃ ማቀናበሪያ መንገድ ነው። መደጋገም አንዳንድ ድርጊቶች ወደ ተደጋጋሚ የፕሮግራም ጥሪዎች ሳይመሩ ብዙ ጊዜ የሚደጋገሙበት የውሂብ ሂደት የማደራጀት መንገድ ነው።

ከዚያ በኋላ እርስ በርስ የሚለዋወጡ ናቸው ብለን መደምደም እንችላለን, ነገር ግን ሁልጊዜ በሀብቶች እና በፍጥነት ተመሳሳይ ወጪዎች አይደሉም. ይህንን ለማረጋገጥ, የሚከተለውን ምሳሌ ልንሰጥ እንችላለን-አንድ የተወሰነ ስልተ-ቀመር ለማደራጀት, በቆጣሪው ወቅታዊ ዋጋ ላይ በመመርኮዝ የእርምጃዎችን ቅደም ተከተል የሚያከናውን አንድ ተግባር አለ (በዚህ ላይ የተመካ ላይሆን ይችላል). እሱ)። ዑደት ስላለ ሰውነት ተከታታይ ድርጊቶችን ይደግማል ማለት ነው - የዑደት ድግግሞሾች። ክዋኔዎችን ወደ የተለየ ንዑስ-ንዑሳን ክፍል መውሰድ እና ካለ የቆጣሪውን ዋጋ ማለፍ ይችላሉ። የንዑስ ክፍሉን አፈፃፀም ከጨረስን በኋላ ዑደቱን ለማስኬድ ሁኔታዎችን እናረጋግጣለን, እና እውነት ከሆነ, ወደ ንዑስ ክፍል አዲስ ጥሪ እንቀጥላለን, አፈፃፀምን እንጨርሳለን. ምክንያቱም ሁሉንም የሉፕ ይዘቶች በንዑስ ክፍል ውስጥ እናስቀምጣለን ፣ ይህ ማለት ዑደቱን የማስፈፀም ሁኔታ በንዑስ ክፍል ውስጥም ይቀመጣል ፣ እና በተግባሩ መመለሻ እሴት በኩል ሊገኝ ይችላል ፣ መለኪያዎች በማጣቀሻ ወይም ጠቋሚ ወደ ንዑስ ክፍል ይተላለፋሉ። , እንዲሁም ዓለም አቀፍ ተለዋዋጮች. በተጨማሪም፣ ከሉፕ ወደ ተሰጠ ንዑስ-ንዑስ-ሥርዓት ጥሪ በቀላሉ ወደ ጥሪ ወይም ጥሪ (እሴት መመለስ ወይም በቀላሉ ሥራን ማጠናቀቅ) በአንዳንድ ሁኔታዎች በመመራት ወደ ንዑስ ንዑስ ክፍል በቀላሉ እንደሚቀየር ለማሳየት ቀላል ነው። ቀደም ሲል በ loop ሁኔታ ውስጥ ነበሩ). አሁን፣ የአብስትራክት ፕሮግራማችንን ከተመለከቱ፣ በግምት እሴቶችን ወደ ንዑስ ክፍል ማስተላለፍ እና እነሱን መጠቀም ይመስላል፣ ይህም ሲጠናቀቅ ንዑስ ክፍሉ ይለወጣል፣ ማለትም። የተሰጠውን ስልተ ቀመር ለመፍታት ተደጋጋሚ ምልክቱን ወደ ንዑስ ክፍል ተደጋጋሚ ጥሪ ተክተናል።

ተደጋጋሚነትን ወደ ተደጋጋሚ አቀራረብ የማምጣት ተግባር የተመጣጠነ ነው።

ለማጠቃለል ያህል, የሚከተሉትን ሀሳቦች መግለጽ እንችላለን-ለእያንዳንዱ አቀራረብ የራሱ የሆነ የሥራ ምድብ አለ, ይህም ለአንድ የተወሰነ ተግባር በተወሰኑ መስፈርቶች ይወሰናል.

ስለዚህ ጉዳይ የበለጠ ማወቅ ይችላሉ

ልክ እንደ ቆጠራ (ዑደት)፣ መደጋገም የማቆም ሁኔታ ሊኖረው ይገባል - የመሠረት ጉዳይ (አለበለዚያ ልክ እንደ ዑደት ፣ ድግግሞሽ ለዘላለም ይሠራል - ማለቂያ የለውም)። ይህ ሁኔታ ተደጋጋሚነት (የተደጋጋሚነት ደረጃ) የሚሄድበት ሁኔታ ነው. በእያንዳንዱ እርምጃ የሚቀጥለው ጥሪ የመነሻውን ሁኔታ እስኪያነሳ ድረስ እና ድጋሚው እስኪቆም ድረስ (ወይም ይልቁንስ ወደ መጨረሻው ተግባር ጥሪ እስኪመለስ ድረስ) ተደጋጋሚ ተግባር ይባላል። አጠቃላይ መፍትሔው ዋናውን ጉዳይ ለመፍታት ነው. ውስብስብ ችግርን ለመፍታት ተደጋጋሚ ተግባር በተጠራበት ጊዜ (የመሠረቱ ጉዳይ ሳይሆን) ችግሩን ወደ ቀላል ለመቀነስ ብዙ ተደጋጋሚ ጥሪዎች ወይም እርምጃዎች ይከናወናሉ። እናም መሰረታዊ መፍትሄ እስክናገኝ ድረስ።

ስለዚህ የተደጋጋሚነት ተግባር ያካትታል

የማቆሚያ ሁኔታ ወይም የመሠረት መያዣ
የመቀጠል ሁኔታ ወይም የመደጋገም ደረጃ ችግርን ወደ ቀላል የመቀነስ መንገድ ነው።

ፋብሪካውን የማግኘት ምሳሌ በመጠቀም ይህንን እንመልከት፡-

የህዝብ ክፍል መፍትሄ (የህዝብ የማይንቀሳቀስ int recursion (int n) (// የመውጫ ሁኔታ // የመሠረት ጉዳይ // ድጋሚ መደጋገሙን መቼ ማቆም እንዳለበት? recursion (n - 1) * n; ) ህዝባዊ የማይንቀሳቀስ ባዶ ዋና (ሕብረቁምፊ አርግስ) (System.out.println (ድግግሞሽ (5)); // ተደጋጋሚ ተግባር ይደውሉ ))

እዚህ መሰረታዊ ሁኔታው በ n=1 ጊዜ ነው. ያንን 1!=1 ስለምናውቅ እና 1 ለማስላት! ምንም ነገር አያስፈልገንም. ለማስላት 2! 1 ን መጠቀም እንችላለን, ማለትም. 2!=1!*2። ለማስላት 3! 2 ያስፈልገናል!*3... n ለማስላት! ያስፈልገናል (n-1)!*n. ይህ የመድገም ደረጃ ነው። በሌላ አገላለጽ የቁጥር n የፋይል እሴት ለማግኘት የቀደመውን ቁጥር የፋይል እሴት በ n ማባዛት በቂ ነው.

መለያዎች