برنامه‌ دنباله فیبوناچی در پایتون

دنباله فیبوناچی با متلب

توی این پست می‌خوام روش ساده‌ای برای بدست آوردن دنباله‌ی فیبوناچی با استفاده از دستورات متلب رو براتون توضیح بدم.

برای این کار پیش‌نیاز زبان برنامه‌نویسی متلب (پایه‌ی زبان C) و اندکی هم فلوچارت نویسی هست که البته اصلا نگران نباشید اگر این‌ ها رو بلد نیستید. چون زبانی بسیار ساده‌ست و به راحتی می‌تونید تحلیلش کنید

همونطور که می‌دونید دنباله‌ی فیبوناچی این شکلیه:

1, 1, 2, 3, 5, 8, 13, 21 و.

اگر کمی بهش دقت کنید متوجه می‌شید که در مرحله اول عدد ۱ رو با ۱ جمع می‌کنیم. مرحله دوم یا به عبارتی جمله‌ی سوم دنباله‌ی فیبوناچی با جمع کردن دو جمله‌ی قبلی حاصل می‌شه یعنی اگر جملات رو با f_n مشخص کنیم، جمله سوم دنباله از طریق رابطه‌ی f₃=f₂+f₁ بدست میاد. و همینطور جمله چهارم هم از حاصل جمع جمله‌ی دوم و سوم، جمله‌ی پنجم از حاصل جمع جمله‌ی چهارم و سوم و الی آخر.

دقیقا کاری که ما می‌خوایم توی محیط متلب انجام بدیم:

این کد‌ها رو ببینید:

برای توضیحش از خط اول شروع می‌کنیم و خط به خط می‌ریم جلو

۱. این دستور به منظور تمیز کردن command prompt متلب استفاده می‌شه و یه جورایی کدهای اضافی رو از صفحه پاک می‌کنه.

۲. هر متغیری که توی workspace شما ذخیره شده باشه با این دستور پاک می‌شه.

۳. برای حلقه‌هایی که داریم باید از یه شمارنده استفاده کنیم. متغیر i رو برای شمارش تعداد تکرارهای حلقه‌مون استفاده می‌کنیم.

۴. جمله‌ی اول دنباله‌ی فیبوناچی رو با مشخص کردن مقدار اولیه برای متغیر f1 مشخص می‌کنیم.

۵. مشابه خط قبلی، جمله‌ی دوم دنباله رو با مشخص کردن مقدار اولیه برای متغیر f2 مشخص می‌کنیم.

۶. حالا وقتشه از کاربر بپرسیم که می‌خواد این دنباله تا چند جمله نمایش داده بشه. یعنی تا کجا این کار ادامه پیدا کنه؟! این مقدار رو از کاربر درخواست می‌کنیم و اون رو توی متغیر n قرار می‌دیم.

۷. ما نیاز به یه حلقه‌ داریم. برای اینکه مجبور نباشیم تمام جملات دنباله رو خودمون وارد کنیم! و این کار توسط کامپیوتر انجام بشه. بنابراین یه حلقه با شرط تعریف می‌کنیم و شرط توقف حلقه رو اینطور تعریف می‌کنیم: مادامی که تعداد جملات نوشته شده به عدد انتخابی کاربر نرسیده حلقه را تکرار کن.

۸. حالا باید برنامه‌ دنباله فیبوناچی در پایتون مشخص کنیم که اگر هنوز تعداد جملاتی که نوشته شده به تعداد جملاتی که کاربر انتخاب کرده نرسیده، چه اتفاقی باید بیفته! پس یه شرط می‌ذاریم و مقدار شرط رو مطابق کدی که نوشتیم انتخاب می‌کنیم.

۹. توی خط اول، اولین جمله‌ی دنباله‌ی خودمون رو چاپ می‌کنیم.

۱۰. مقدار جمله‌ی سوم رو از مقدار دو جمله‌ی قبلی محاسبه می‌کنیم.

۱۱. از اینجا به بعد یک مقدار کمی پیچیده می‌شه ماجرا. چرا؟! چون باید یک سری تغییراتی توی جملاتمون بدیم. به توضیحات زیر دقت کنید:

شما در تکرار اول این حلقه، مقدار f₃ رو محاسبه می‌کنید. یعنی تا الان اعداد زیر رو بدست آوردید:

و جمله‌ی اول رو چاپ کردید. یعنی تا الان خروجیتون به این صورته:

توی خط ۱۱ کاری که ما انجام می‌دیم اینه که، اعداد رو یه دونه به عقب هل می‌دیم. یعنی چی؟ دنباله فیبوناچی رو اینجا رو ببینید:

و کاری که ما در این مرحله و مرحله‌ی بعدی یعنی خط ۱۲ انجام می‌دیم این دنباله رو به شکل زیر تغییر می‌ده:

فهمیدید چی شد؟ ما با این کار عدد اول دنباله رو نوشتیم و از گردونه‌ی اعداد خارجش کردیم.

حالا باید دوباره اولین عددی که داریم رو بنویسیم.

۱۲. توضیحات مرحله‌ی (خط) ۱۱ رو با دقت بخونید.

۱۳. شمارنده‌ی ما برای اینکه بتونیم تشخیص بدیم تو چه مرحله‌ای هستیم باید یک واحد افزایش پیدا کنه.

۱۴. اما اگر از ابتدا، جمله‌ای که مشخص کردیم یا عدد n برابر صفر بود چی؟!

۱۵. فقط مقدار جمله‌ی اول یا همون ۱ در خروجی نوشته می‌شه و دستور توقف برنامه صادر می‌شه.برنامه‌ دنباله فیبوناچی در پایتون

حالا خودتون هم این کار رو انجام بدید.

ممنون می‌شم اگر سوالی داشتید از طریق کامنت‌ها مطرح کنید تا با هم دیگه بهش پاسخ بدیم.

این پست رو به دوستانتون هم معرفی کنید.

جمله‌ی ,رو ,جمع ,فیبوناچی ,سوم ,حاصل ,دنباله‌ی فیبوناچی ,فیبوناچی با ,از حاصل ,حاصل جمع ,جمع جمله‌ی

یافتن عدد فیبوناچی N به سه روش در زمان معقول: اصول برنامه نویسی پویا. یافتن عدد فیبوناچی N به سه روش برنامه‌ دنباله فیبوناچی در پایتون در زمان معقول: مبانی برنامه نویسی پویا

اعداد فیبوناچی- این یک سری اعداد است که در آن هر عدد بعدی برابر است با مجموع دو عدد قبلی: 1، 1، 2، 3، 5، 8، 13، . گاهی اوقات سریال از صفر شروع می شود: 0، 1، 1، 2، 3، 5، . در این صورت ما به گزینه اول پایبند خواهیم بود.

F1=1
F2 = 1
F n \u003d F n-1 + F n-2

مثال محاسبه:

F 3 \u003d F 2 + F 1 \u003d 1 + 1 \u003d 2
F 4 \u003d F 3 + F 2 \u003d 2 + 1 \u003d 3
F 5 \u003d F 4 + F 3 \u003d 3 + 2 \u003d 5
F 6 \u003d F 5 + F 4 \u003d 5 + 3 \u003d 8
.

محاسبه عدد n یک سری فیبوناچی با حلقه while

1. مقادیر دو عنصر اول سری را به متغیرهای fib1 و fib2 اختصاص دهید، یعنی واحدهایی را به متغیرها اختصاص دهید.
2. از کاربر شماره عنصری را که می‌خواهد مقدار آن را بدست آورد بپرسید. یک عدد به متغیر n اختصاص دهید.
3. مراحل زیر را n - 2 بار انجام دهید، زیرا دو عنصر اول قبلاً در نظر گرفته شده است:
   1. fib1 و fib2 را اضافه کنید و نتیجه را به یک متغیر ذخیره سازی موقت، مانند fib_sum اختصاص دهید.
   2. fib1 را روی fib2 قرار دهید.
   3. fib2 را روی fib_sum برنامه‌ دنباله فیبوناچی در پایتون قرار دهید.

   توجه داشته باشید.اگر کاربر 1 یا 2 را وارد کند، بدنه حلقه هرگز اجرا نمی شود و مقدار اصلی fib2 نمایش داده می شود.

   fib1=1 fib2=1 n=input() n=int(n) i=0 در حالی که i "عدد عنصر سری فیبوناچی:" ) ) - 2 در حالی که n > 0 : fib1، fib2 = fib2، fib1 + fib2 n -= 1 چاپ (fib2)

   خروجی اعداد فیبوناچی با حلقه for

   در این حالت نه تنها مقدار عنصر مورد نظر از سری فیبوناچی نمایش داده می شود، بلکه تمام اعداد تا و شامل آن نمایش داده می شود. برای انجام این کار، خروجی مقدار fib2 در یک حلقه قرار می گیرد.

   fib1 = fib2 = 1 n = int (ورودی () ) اگر n باشد از طریق تکرار، cache2 ارتباط خود را از دست خواهد داد، یعنی. باید به cache1 تبدیل شود //به عبارت دیگر cache1 -- f(n-2), cache2 -- f(n-1), cache3 -- f(n). //بگذارید N=n+1 (عددی که در تکرار بعدی محاسبه می کنیم). سپس n-2=N-3، n-1=N-2، n=N-1. // مطابق با واقعیت های جدید، مقادیر متغیرهای خود را بازنویسی می کنیم: cache1 = cache2; cache2 = cache3; ) قطع برنامه‌ دنباله فیبوناچی در پایتون کردن 2 other 1

   خوب:
   یک پیاده سازی بسیار ساده که تعریف ریاضی را تکرار می کند
   بد:
   زمان اجرا نمایی برای n بزرگ خیلی آهسته
   شر:
   سرریز پشته

   حفظ کردن

   راه حل بازگشتی یک مشکل بزرگ دارد: همپوشانی محاسبات. هنگامی که fib(n) فراخوانی می شود، fib(n-1) و fib(n-2) شمارش می شوند. اما وقتی fib(n-1) شمارش می شود، به طور مستقل دوباره fib(n-2) را می شمارد - یعنی fib(n-2) دو بار شمارش می شود. اگر استدلال را ادامه دهیم، مشاهده می شود که fib(n-3) سه بار شمارش می شود و به همین ترتیب. تقاطع های خیلی زیاد

   بنابراین، فقط باید نتایج را به خاطر بسپارید تا دوباره آنها را بشمارید. این راه حل زمان و حافظه را به صورت خطی مصرف می کند. من از دیکشنری در راه حل استفاده می کنم، اما می توان از یک آرایه ساده نیز استفاده کرد.

   M = (0: 0، 1: 1) def fib(n): اگر n در M: بازگشت M[n] M[n] = fib(n - 1) + fib(n - 2) بازگشت M[n]

   (در پایتون، این کار را می توان با یک دکوراتور، functools.lru_cache نیز انجام داد.)

   خوب:
   فقط بازگشت را به یک راه حل به خاطر بسپارید. زمان اجرای نمایی را به زمان اجرای خطی تبدیل می کند که حافظه بیشتری مصرف می کند.
   بد:
   حافظه زیادی را تلف می کند
   شر:
   سرریز پشته احتمالی، مانند بازگشت

   برنامه نویسی پویا

   پس از حل با حفظ، مشخص می شود که ما به تمام نتایج قبلی نیاز نداریم، بلکه فقط به دو نتیجه آخر نیاز داریم. همچنین، به جای شروع از fib(n) و رفتن به عقب، می توانید از fib(0) شروع کنید و به جلو بروید. کد زیر دارای زمان اجرای خطی و مصرف حافظه ثابت است. در عمل، سرعت حل حتی سریعتر خواهد بود، زیرا هیچ فراخوانی تابع بازگشتی و کار مرتبط وجود ندارد. و کد ساده تر به نظر می رسد.

   این راه حل اغلب به عنوان نمونه ای از برنامه نویسی پویا ذکر می شود.

   تعریف fib(n): a = 0 b = 1 برای __ در محدوده(n): a، b = b، a + b a را برمی گرداند

   خوب:
   سریع برای کد n کوچک و ساده
   بد:
   هنوز زمان اجرا خطی است
   شر:
   بله، چیز خاصی نیست.

   جبر ماتریسی

   و در نهایت، کمترین پوشش، اما صحیح ترین راه حلی که به طور هوشمندانه از زمان و حافظه استفاده می کند. همچنین می توان آن را به هر دنباله خطی همگن گسترش داد. ایده استفاده از ماتریس است. فقط دیدن آن کافی است

   

   و تعمیم این است که

   

   دو مقداری که قبلاً برای x به دست آوردیم، که یکی از آنها نسبت طلایی بود، مقادیر ویژه ماتریس هستند. بنابراین، راه دیگر برای استخراج فرمول بسته، استفاده از معادله ماتریسی و جبر خطی است.

   پس چرا این عبارت مفید است؟ این واقعیت که توان را می توان در زمان لگاریتمی انجام داد. این کار از طریق مربع انجام می شود. نکته اصلی این است که

   

   جایی که عبارت اول برای زوج A، دومی برای فرد استفاده می شود. فقط برای سازماندهی ضرب ماتریس ها باقی مانده است و همه چیز آماده است. کد زیر معلوم می شود. من یک پیاده سازی بازگشتی از pow را سازماندهی کردم زیرا درک آن آسان تر است. نسخه تکراری را اینجا ببینید.

   Def pow(x, n, I, mult): """ x را به توان n برمی گرداند. فرض می کنیم I همان ماتریس است که با mult ضرب می شود و n یک عدد صحیح مثبت """ است اگر n == 0: بازگشت I است. elif n == 1: برگردان x دیگری: y = pow(x, n // 2, I, mult) y = mult(y, y) اگر n % 2: y = mult(x, y) برگردان y defident_matrix (n): """یک n به n ماتریس هویت را برمی گرداند""" r = list(range(n)) بازگشت [ برای j در r] def matrix_multiply(A, B): BT = list(zip(*B) ) بازگشت [ برای row_a برنامه‌ دنباله فیبوناچی در پایتون در A] def fib(n): F = pow([, ], n,identity_matrix(2), matrix_multiply) بازگشت F

   خوب:
   اندازه حافظه ثابت، زمان لگاریتمی
   بد:
   کد پیچیده تر است
   شر:
   شما باید با ماتریس ها کار کنید، اگرچه آنها چندان بد نیستند

   مقایسه عملکرد

   ارزش مقایسه فقط نوع برنامه نویسی پویا و ماتریس را دارد. اگر آنها را با تعداد ارقام در عدد n مقایسه کنیم، معلوم می شود که راه حل ماتریس خطی است و راه حل با برنامه ریزی پویا نمایی است. یک مثال عملی محاسبه fib(10*6) است، عددی که بیش از دویست هزار کاراکتر خواهد داشت.

   N=10**6
   محاسبه fib_matrix: fib(n) در مجموع دارای 208988 رقم است، محاسبه 0.24993 ثانیه طول کشید.
   محاسبه fib_dynamic: fib(n) در مجموع دارای 208988 رقم است، محاسبه 11.83377 ثانیه طول کشید.

   اظهارات نظری

   

   بیایید تعداد مسیرهای به طول n را از A تا B بشماریم. برای مثال، برای n = 1 یک مسیر داریم، 1. برای n = 2، دوباره یک مسیر، 01. برای n = 3، دو مسیر داریم. ، 001 و 101 می توان به سادگی نشان داد که تعداد مسیرهای به طول n از A تا B دقیقاً F n است. پس از نوشتن ماتریس مجاورت برای نمودار، همان ماتریسی را خواهیم گرفت که در بالا توضیح داده شد. این یک نتیجه شناخته شده از نظریه گراف است که با توجه به یک ماتریس مجاورت A، وقوع در A، n تعداد مسیرهایی به طول n در نمودار است (یکی از مشکلات ذکر شده در فیلم Good Will Hunting).

   چرا چنین علامت هایی در لبه ها وجود دارد؟ معلوم می‌شود که وقتی یک دنباله نامتناهی از نمادها را روی یک بی‌نهایت در هر دو جهت دنباله‌ای از مسیرها در یک نمودار در نظر می‌گیریم، چیزی به نام «subshifts از نوع محدود» به دست می‌آید که نوعی سیستم دینامیک نمادین است. به طور خاص، این جابجایی فرعی از نوع محدود به عنوان «تغییر نسبت طلایی» شناخته می‌شود و با مجموعه‌ای از «کلمات ممنوعه» (11) ارائه می‌شود. به عبارت دیگر دنباله های باینری خواهیم داشت که در هر دو جهت بی نهایت هستند و هیچ جفتی مجاور نخواهد بود. آنتروپی توپولوژیکی این سیستم دینامیکی برابر با نسبت طلایی φ است. جالب است که چگونه این عدد به صورت دوره ای در حوزه های مختلف ریاضیات ظاهر می شود.

   پایتون :حل مثال های برنامه نویسی پایتون تابع ها

   برنامه نویسی پایتون نیاز به تمرین و تکرار داره برای همین این جلسه فقط مثال ها و تمرین های تابع های پایتون را حل میکنیم و در آخر جلسه به شما چندین تمرین میدم از متوسط به سخت سعی کنید این تمرین های برنامه نویسی را انجام بدید تا پایتون را یاد بگیرید ______________________________________________________________ 00:00این ویدیو 00:24تمرین اول عدد بزرگتر! 02:07تمرین دوم دنباله فیبوناچی 09:49تمرین سوم لیست های بزگ 15:23. تمرین های شما _______________________________________________________________ For more communication with me: youtube: https://www.youtube.com/c/skilltop telegram: https://telegram.me/skill_top instagram: https://www.instagram.com/skilltop_

   

   

   

   

   

   Report submitted! New Report Was Received Successfully Thank you for this report. We'll check that in next 24 hours (maximum time), please wait for privacy officers. Kind Regards, Daneshgah Team

   Reported before! (Please wait for maximum 24 hours) Thank you for this report but we received another report in this day. We'll check that in next 24 hours (maximum time), please wait for privacy officers. Report Was Received Before Kind Regards, Daneshgah Team