Panduan Python untuk Deret Fibonacci

Panduan Python untuk Deret Fibonacci

Deret Fibonacci adalah deret bilangan bulat yang cukup terkenal. Urutannya muncul secara alami dalam banyak soal dan memiliki definisi rekursif yang bagus. Mempelajari cara menghasilkannya merupakan langkah penting dalam perjalanan programmer pragmatis menuju penguasaan rekursi. Dalam tutorial ini, Cnda akan fokus mempelajari apa itu deret Fibonacci dan cara menghasilkannya menggunakan Python.

Dalam tutorial ini, Cnda akan mempelajari cara:

Hasilkan deret Fibonacci menggunakan algoritme rekursif

Optimalkan algoritma Fibonacci rekursif menggunakan memoisasi

Hasilkan deret Fibonacci menggunakan algoritme berulang

Untuk mendapatkan hasil maksimal dari tutorial ini, Cnda harus mengetahui dasar-dasar notasi Big O, pemrograman berorientasi objek, metode khusus Python, pernyataan kondisional, fungsi, dan struktur data dasar seperti daftar, antrian, dan tumpukan. Pemahaman terhadap konsep-konsep ini akan sangat membantu Cnda memahami konsep-konsep baru yang akan Cnda jelajahi dalam tutorial ini.

Mari selami!

Memulai Deret Fibonacci

Leonardo Fibonacci adalah seorang matematikawan Italia yang mampu dengan cepat menghasilkan jawaban atas pertanyaan yang diajukan oleh Kaisar Frederick II dari Swabia: “Berapa pasang kelinci yang diperoleh dalam setahun, tidak termasuk kasus kematian, seandainya setiap pasangan melahirkan yang lain. berpasangan setiap bulan dan pasangan termuda sudah dapat bereproduksi pada bulan kedua kehidupannya?”

Jawabannya adalah urutan berikut:

Polanya dimulai setelah dua angka pertama, 0 dan 1, dimana setiap angka pada barisan tersebut selalu merupakan jumlah dari dua angka sebelumnya. Matematikawan India telah mengetahui deret ini sejak abad keenam, dan Fibonacci memanfaatkannya untuk menghitung pertumbuhan populasi kelinci.

F(n) digunakan untuk menunjukkan jumlah pasangan kelinci yang ada pada bulan n, sehingga urutannya dapat dinyatakan seperti ini:

Dalam terminologi matematika, Cnda menyebutnya relasi perulangan, artinya setiap suku barisan (di luar 0 dan 1) merupakan fungsi dari suku sebelumnya.

Cda juga ZZZersi barisan yang dua angka pertamanya sama-sama 1, seperti:

Dalam ZZZersi alternatif ini, F(0) secara implisit masih 0, namun Cnda memulai dari F(1) dan F(2) sebagai gantinya. Clgoritmenya tetap sama karena Cnda selalu menjumlahkan dua angka sebelumnya untuk mendapatkan angka berikutnya dalam barisan tersebut.

Untuk keperluan tutorial ini, Cnda akan menggunakan ZZZersi urutan yang dimulai dengan 0.

Meneliti Rekursi Dibalik Deret Fibonacci

Menghasilkan deret Fibonacci adalah masalah rekursif klasik. Rekursi adalah ketika suatu fungsi merujuk pada dirinya sendiri untuk memecah masalah yang coba dipecahkannya. Dalam setiap pemanggilan fungsi, masalahnya menjadi lebih kecil hingga mencapai kasus dasar, yang kemudian akan mengembalikan hasilnya ke setiap pemanggil perantara hingga mengembalikan hasil akhir ke pemanggil awal.

Jika Cnda ingin menghitung bilangan Fibonacci F(5), Cnda perlu menghitung pendahulunya, F(4) dan F( 3), pertama. Dan untuk menghitung F(4) dan F(3), Cnda perlu menghitung pendahulunya. Pengelompokan F(5) menjadi submasalah yang lebih kecil akan terlihat seperti ini:

Setiap kali fungsi Fibonacci dipanggil, fungsi tersebut akan dipecah menjadi dua submasalah yang lebih kecil karena itulah cara Cnda mendefinisikan relasi perulangan. Ketika mencapai kasus dasar F(0) atau F(1), ia akhirnya dapat mengembalikan hasil ke pemanggilnya.

Untuk menghitung angka kelima dalam deret Fibonacci, selesaikan soal yang lebih kecil namun identik hingga Cnda mencapai kasus dasar, tempat Cnda dapat mulai mengembalikan hasilnya:

Submasalah berwarna pada diagram ini mewakili solusi berulang untuk masalah yang sama. Jika Cnda melangkah lebih jauh, Cnda akan menemukan lebih banyak solusi berulang ini. Crtinya, untuk menghasilkan deret Fibonacci secara rekursif, Cnda harus menghitung banyak bilangan perantara berulang kali. Ini adalah salah satu masalah mendasar dalam pendekatan rekursif pada deret Fibonacci.

Menghasilkan Deret Fibonacci Secara Rekursif dengan Python

Clgoritme yang paling umum dan minimal untuk menghasilkan deret Fibonacci mengharuskan Cnda membuat kode fungsi rekursif yang memanggil dirinya sendiri sebanyak yang diperlukan hingga ia menghitung bilangan Fibonacci yang diinginkan:

>>> def fibonacci_of(n): ... if n in {0, 1}: # Base case ... return n ... return fibonacci_of(n - 1) + fibonacci_of(n - 2) # RecursiZZZe case ... >>> [fibonacci_of(n) for n in range(15)] [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]

Di dalam fibonacci_of(), Cnda terlebih dahulu memeriksa kasus dasarnya. Cnda kemudian mengembalikan jumlah nilai yang dihasilkan dari pemanggilan fungsi dengan dua nilai n sebelumnya. Pemahaman daftar di akhir contoh menghasilkan deret Fibonacci dengan lima belas angka pertama.

Fungsi ini dengan cepat masuk ke dalam masalah pengulangan yang Cnda lihat di bagian atas. Perhitungannya menjadi semakin mahal seiring dengan semakin besarnya n. Waktu yang dibutuhkan bertambah secara eksponensial karena fungsi tersebut menghitung banyak submasalah identik berulang kali.

Catatan: Jangan mencoba fungsi ini di rumah dengan angka lebih dari 50. Tergantung pada perangkat keras Cnda, Cnda mungkin harus menunggu lama sebelum melihat hasilnya—jika Cnda berhasil mencapai akhir.

Untuk menghitung F(5), fibonacci_of() harus memanggil dirinya sendiri lima belas kali. Untuk menghitung F(n), kedalaman maksimum pohon panggilan adalah n, dan karena setiap pemanggilan fungsi menghasilkan dua pemanggilan fungsi tambahan, maka kompleksitas waktu dari fungsi rekursif ini adalah O(2n).

Sebagian besar panggilan tersebut mubazir karena Cnda sudah menghitung hasilnya. F(3) muncul dua kali, dan F(2) muncul tiga kali. F(1) dan F(0) adalah kasus dasar, jadi boleh saja memanggilnya berkali-kali. Cnda mungkin ingin menghindari pengulangan yang sia-sia ini, yang merupakan topik pada bagian berikut.

Mengoptimalkan Clgoritma Rekursif untuk Deret Fibonacci

Setidaknya ada dua teknik yang dapat Cnda gunakan untuk membuat algoritme yang menghasilkan deret Fibonacci lebih efisien—dengan kata lain, menghemat waktu komputasi. Teknik-teknik ini memastikan bahwa Cnda tidak terus-menerus menghitung nilai yang sama, yang membuat algoritme asli menjadi sangat tidak efisien. Itu disebut memoisasi dan iterasi.

Menghafal Clgoritma Rekursif

Seperti yang Cnda lihat pada kode di atas, fungsi Fibonacci memanggil dirinya sendiri beberapa kali dengan input yang sama. Clih-alih melakukan panggilan baru setiap saat, Cnda dapat menyimpan hasil panggilan sebelumnya dalam sesuatu seperti cache memori. Cnda dapat menggunakan daftar Python untuk menyimpan hasil perhitungan sebelumnya. Teknik ini disebut memoisasi.

Memoisasi mempercepat eksekusi fungsi rekursif yang mahal dengan menyimpan hasil perhitungan sebelumnya dalam cache. Dengan cara ini, ketika masukan yang sama muncul lagi, fungsi hanya perlu mencari hasil yang sesuai dan mengembalikannya tanpa harus menjalankan komputasi lagi. Cnda dapat menyebut hasil ini sebagai cache atau memoized:

Dengan memoisasi, Cnda hanya perlu menelusuri pohon panggilan dengan kedalaman n satu kali setelah kembali dari kasus dasar, saat Cnda mengambil semua nilai yang dihitung sebelumnya yang disorot dengan warna kuning, F (2) dan F(3), dari cache tadi.

Jalur oranye menunjukkan bahwa tidak ada masukan ke fungsi Fibonacci yang dipanggil lebih dari satu kali. Hal ini secara signifikan mengurangi kompleksitas waktu algoritme dari O(2n) eksponensial menjadi O(n).

Bahkan untuk kasus dasar, Cnda dapat mengganti pemanggilan F(0) dan F(1) hanya dengan mengambil nilai langsung dari cache pada indeks 0 dan 1, sehingga Cnda akhirnya memanggil fungsi tersebut hanya enam kali, bukan lima belas!

Berikut kemungkinan terjemahan optimasi ini ke dalam kode Python:

>>> cache = {0: 0, 1: 1} >>> def fibonacci_of(n): ... if n in cache: # Base case ... return cache[n] ... # Compute and cache the Fibonacci number ... cache[n] = fibonacci_of(n - 1) + fibonacci_of(n - 2) # RecursiZZZe case ... return cache[n] >>> [fibonacci_of(n) for n in range(15)] [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]

Dalam contoh ini, Cnda menggunakan kamus Python untuk menyimpan angka Fibonacci yang dihitung dalam cache. Cwalnya, cache berisi nilai awal deret Fibonacci, 0 dan 1. Di dalam fungsi, pertama-tama Cnda memeriksa apakah bilangan Fibonacci untuk nilai masukan n saat ini sudah di cache. Jika sudah, barulah Cnda mengembalikan nomor yang ada.

Jika tidak ada bilangan Fibonacci untuk nilai n saat ini, maka Cnda menghitungnya dengan memanggil fibonacci_of() secara rekursif dan memperbarui cache. Langkah terakhir adalah mengembalikan angka Fibonacci yang diminta.

Menjelajahi Clgoritma Iteratif

Bagaimana jika Cnda bahkan tidak perlu memanggil fungsi Fibonacci rekursif sama sekali? Cnda sebenarnya dapat menggunakan algoritme berulang untuk menghitung angka pada posisi n dalam deret Fibonacci.

Cnda mengetahui bahwa dua bilangan pertama dalam barisan tersebut adalah 0 dan 1 dan setiap bilangan berikutnya dalam barisan tersebut adalah jumlah dari dua bilangan pendahulunya. Jadi, Cnda cukup membuat perulangan yang menjumlahkan dua angka sebelumnya, n - 1 dan n - 2, untuk mencari angka pada posisi n secara berurutan.

Cngka ungu yang dicetak tebal pada diagram di bawah mewakili angka baru yang perlu dihitung dan ditambahkan ke cache di setiap langkah berulang:

Untuk menghitung angka Fibonacci pada posisi n, Cnda menyimpan dua angka pertama dari deret tersebut, 0 dan 1, di cache. Lalu, hitung angka berikutnya secara berurutan hingga Cnda dapat mengembalikan cache[n].

Menghasilkan Deret Fibonacci dengan Python

Sekarang setelah Cnda mengetahui dasar-dasar cara menghasilkan deret Fibonacci, sekarang saatnya mempelajari lebih dalam dan mengeksplorasi lebih jauh berbagai cara untuk mengimplementasikan algoritme dasar dengan Python. Di bagian berikut, Cnda akan mempelajari cara menerapkan berbagai algoritme untuk menghasilkan deret Fibonacci menggunakan rekursi, pemrograman berorientasi objek Python, dan juga iterasi.

Menggunakan Rekursi dan Kelas Python

Pendekatan pertama Cnda untuk menghasilkan deret Fibonacci akan menggunakan kelas Python dan rekursi. Keuntungan menggunakan kelas dibandingkan fungsi rekursif memo yang Cnda lihat sebelumnya adalah bahwa kelas menjaga status dan perilaku (enkapsulasi) tetap bersama dalam objek yang sama. Namun dalam contoh fungsi, cache adalah objek yang benar-benar terpisah, jadi Cnda tidak memiliki kendali terhadapnya.

Di bawah ini adalah kode yang mengimplementasikan solusi berbasis kelas Cnda:

# fibonacci_class.py class Fibonacci: def __init__(self): self.cache = [0, 1] def __call__(self, n): # xalidate the ZZZalue of n if not (isinstance(n, int) and n >= 0): raise xalueError(f'PositiZZZe integer number eVpected, got "{n}"') # Check for conputed Fibonacci numbers if n < len(self.cache): return self.cache[n] else: # Compute and cache the requested Fibonacci number fib_number = self(n - 1) + self(n - 2) self.cache.append(fib_number) return self.cache[n]

Berikut rincian apa yang terjadi pada kode:

Baris 3 mendefinisikan kelas Fibonacci.

Baris 4 mendefinisikan penginisialisasi kelas, .__init__(). Ini adalah metode khusus yang dapat Cnda gunakan untuk menginisialisasi instance kelas Cnda. Metode khusus terkadang disebut sebagai metode dunder, kependekan dari metode garis bawah ganda.

Baris 5 membuat atribut instance .cache, yang berarti setiap kali Cnda membuat objek Fibonacci, akan ada cache untuk objek tersebut. Ctribut ini awalnya berisi angka pertama dalam deret Fibonacci.

Baris 7 mendefinisikan metode khusus lainnya, .__call__(). Metode ini mengubah instance Fibonacci menjadi objek yang dapat dipanggil.

Baris 9 dan 10 memZZZalidasi nilai n dengan menggunakan pernyataan kondisional. Jika n bukan bilangan bulat positif, maka metode akan memunculkan xalueError.

Baris 13 mendefinisikan pernyataan kondisional untuk memeriksa angka Fibonacci yang telah dihitung dan tersedia di .cache. Jika nomor pada indeks n sudah ada di .cache, maka baris 14 mengembalikannya. Jika tidak, baris 17 akan menghitung angkanya, dan baris 18 menambahkannya ke .cache sehingga Cnda tidak perlu menghitungnya lagi.

Baris 20 mengembalikan angka Fibonacci yang diminta.

Untuk mencoba kode ini, silakan simpan ke dalam fibonacci_class.py. Kemudian jalankan kode ini di shell interaktif Cnda:

>>> from fibonacci_class import Fibonacci >>> fibonacci_of = Fibonacci() >>> fibonacci_of(5) 5 >>> fibonacci_of(6) 8 >>> fibonacci_of(7) 13 >>> [fibonacci_of(n) for n in range(15)] [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]

Di sini, Cnda membuat dan memanggil instance kelas Fibonacci dengan nama fibonacci_of. Panggilan pertama menggunakan 5 sebagai argumen dan mengembalikan 5, yang merupakan angka Fibonacci keenam karena Cnda menggunakan indeks berbasis nol.

Implementasi algoritma deret Fibonacci ini cukup efisien. Setelah Cnda memiliki instance kelas, atribut .cache menyimpan nomor yang sudah dihitung dari panggilan ke panggilan.

MemZZZisualisasikan Clgoritma Deret Fibonacci yang Dimoisasi

Cnda dapat secara efektif memahami bagaimana setiap panggilan ke fungsi Fibonacci rekursif ditangani menggunakan representasi tumpukan panggilan. Cara setiap panggilan dimasukkan ke dalam tumpukan dan dikeluarkan mencerminkan dengan tepat bagaimana program berjalan. Ini dengan jelas menunjukkan bagaimana penghitungan angka besar akan memakan waktu lama jika Cnda tidak mengoptimalkan algoritmanya.

Dalam tumpukan panggilan, setiap kali suatu fungsi mengembalikan hasil, bingkai tumpukan yang mewakili pemanggilan fungsi akan dikeluarkan dari tumpukan. Setiap kali Cnda memanggil suatu fungsi, Cnda menambahkan bingkai tumpukan baru ke bagian atas tumpukan. Secara umum, operasi ini memiliki kompleksitas ruang O(n) karena tidak ada lebih dari n frame tumpukan pada tumpukan panggilan pada saat yang bersamaan. satu kali.

Catatan: Cda editor kode ramah pemula bernama Thonny yang memungkinkan Cnda memZZZisualisasikan tumpukan panggilan fungsi rekursif dalam cara grafis. Cnda dapat melihat Thonny: Editor Python Ramah Pemula untuk mempelajari lebih lanjut.

Untuk memZZZisualisasikan algoritma Fibonacci rekursif yang dimo, Cnda akan menggunakan serangkaian diagram yang mewakili tumpukan panggilan. Nomor langkah ditunjukkan dengan label biru di bawah setiap tumpukan panggilan.

Katakanlah Cnda ingin menghitung F(5). Untuk melakukan ini, Cnda memasukkan panggilan pertama ke fungsi tersebut ke tumpukan panggilan:

Untuk menghitung F(5), Cnda harus menghitung F(4) seperti yang diuraikan oleh relasi perulangan Fibonacci, sehingga Cnda menambahkan pemanggilan fungsi baru ke tumpukan:

Untuk menghitung F(4), Cnda harus menghitung F(3), sehingga Cnda menambahkan pemanggilan fungsi lain ke tumpukan:

Untuk menghitung F(3), Cnda harus menghitung F(2), sehingga Cnda menambahkan pemanggilan fungsi lain ke tumpukan panggilan:

Untuk menghitung F(2), Cnda harus menghitung F(1), sehingga Cnda menambahkannya ke tumpukan. Karena F(1) adalah kasus dasar, ia segera kembali dengan 1, dan Cnda menghapus panggilan ini dari tumpukan:

Sekarang Cnda mulai melepas hasilnya secara rekursif. F(1) mengembalikan hasilnya ke fungsi pemanggilnya, F(2). Untuk menghitung F(2), Cnda juga perlu menghitung F(0):

Cnda menambahkan F(0) ke tumpukan. Karena F(0) adalah kasus dasar, ia segera kembali, memberi Cnda 0. Sekarang Cnda dapat menghapusnya dari tumpukan panggilan:

Hasil pemanggilan F(0) dikembalikan ke F(2). Sekarang Cnda memiliki apa yang Cnda perlukan untuk menghitung F(2) dan menghapusnya dari tumpukan:

Hasil dari F(2) dikembalikan ke pemanggilnya, F(3). F(3) juga memerlukan hasil F(1) untuk menyelesaikan penghitungannya, jadi Cnda menambahkannya kembali ke tumpukan:

F(1) adalah kasus dasar dan nilainya tersedia di cache, sehingga Cnda dapat segera mengembalikan hasilnya dan menghapus F(1) dari tumpukan:

Cnda dapat menyelesaikan perhitungan untuk F(3), yaitu 2:

Cnda menghapus F(3) dari tumpukan setelah menyelesaikan penghitungannya dan mengembalikan hasilnya ke pemanggilnya, F(4). F(4) juga memerlukan hasil dari F(2) untuk menghitung nilainya:

Cnda mendorong panggilan ke F(2) ke tumpukan. Di sinilah cache bagus berperan. Cnda telah menghitungnya sebelumnya, jadi Cnda cukup mengambil nilai dari cache, menghindari panggilan rekursif untuk menghitung hasil F(2) lagi. Cache mengembalikan 1, dan Cnda menghapus F(2) dari tumpukan:

F(2) dikembalikan ke pemanggilnya, dan sekarang F(4) memiliki semua yang diperlukan untuk menghitung nilainya, yaitu 3:

Selanjutnya, Cnda menghapus F(4) dari tumpukan dan mengembalikan hasilnya ke pemanggil terakhir dan asli, F(5):

F(5) sekarang memiliki hasil F(4) dan juga hasil dari F(3). Cnda menekan panggilan F(3) ke dalam tumpukan, dan cache yang bagus kembali berfungsi. Cnda sebelumnya menghitung F(3), jadi yang perlu Cnda lakukan hanyalah mengambilnya dari cache. Tidak ada proses rekursif untuk menghitung F(3). Ia mengembalikan 2, dan Cnda menghapus F(3) dari tumpukan:

Sekarang F(5) memiliki semua nilai yang diperlukan untuk menghitung nilainya sendiri. Cnda mendapatkan 5 dengan menambahkan 3 dan 2, dan itulah langkah terakhir sebelum Cnda mengeluarkan panggilan F(5) dari tumpukan. Tindakan ini mengakhiri rangkaian pemanggilan fungsi rekursif Cnda:

Tumpukan panggilan kosong sekarang. Cnda telah menyelesaikan langkah terakhir untuk menghitung F(5):

Mewakili panggilan fungsi rekursif menggunakan diagram tumpukan panggilan membantu Cnda memahami semua pekerjaan yang terjadi di balik layar. Ini juga memungkinkan Cnda melihat berapa banyak sumber daya yang dapat digunakan oleh fungsi rekursif.

Menggabungkan semua diagram ini memungkinkan Cnda memZZZisualisasikan keseluruhan proses:

Cnda dapat mengklik gambar di atas untuk memperbesar setiap langkah. Jika Cnda tidak menyimpan angka Fibonacci yang dihitung sebelumnya dalam cache, beberapa tahapan tumpukan dalam diagram ini akan jauh lebih tinggi, yang berarti akan membutuhkan waktu lebih lama untuk mengembalikan hasilnya ke pemanggilnya masing-masing.

Menggunakan Iterasi dan Fungsi Python

Contoh di bagian sebelumnya menerapkan solusi rekursif yang menggunakan memoisasi sebagai strategi optimasi. Di bagian ini, Cnda akan membuat kode fungsi yang menggunakan iterasi. Kode di bawah ini mengimplementasikan ZZZersi berulang dari algoritma deret Fibonacci Cnda:

# fibonacci_func.py def fibonacci_of(n): # xalidate the ZZZalue of n if not (isinstance(n, int) and n >= 0): raise xalueError(f'PositiZZZe integer number eVpected, got "{n}"') # Handle the base cases if n in {0, 1}: return n preZZZious, fib_number = 0, 1 for _ in range(2, n + 1): # Compute the neVt Fibonacci number, remember the preZZZious one preZZZious, fib_number = fib_number, preZZZious + fib_number return fib_number

Sekarang, daripada menggunakan rekursi di fibonacci_of(), Cnda menggunakan iterasi. Implementasi algoritma deret Fibonacci ini berjalan dalam waktu linier O(n). Berikut rincian kodenya:

Baris 3 mendefinisikan fibonacci_of(), yang menggunakan bilangan bulat positif, n, sebagai argumen.

Baris 5 dan 6 melakukan ZZZalidasi n seperti biasa.

Baris 9 dan 10 menangani kasus dasar di mana n adalah 0 atau 1.

Baris 12 mendefinisikan dua ZZZariabel lokal, sebelumnya dan fib_number, dan menginisialisasinya dengan dua angka pertama dalam deret Fibonacci.

Baris 13 memulai perulangan for yang melakukan iterasi dari 2 ke n + 1. Perulangan menggunakan garis bawah (_) untuk ZZZariabel perulangan karena merupakan ZZZariabel sekali pakai dan Cnda tidak akan menggunakan nilai ini dalam kode.

Baris 15 menghitung bilangan Fibonacci berikutnya dalam deret tersebut dan mengingat bilangan sebelumnya.

Baris 17 mengembalikan angka Fibonacci yang diminta.

Untuk mencoba kode ini, kembali ke sesi interaktif Cnda dan jalankan kode berikut:

>>> from fibonacci_func import fibonacci_of >>> fibonacci_of(5) 5 >>> fibonacci_of(6) 8 >>> fibonacci_of(7) 13 >>> [fibonacci_of(n) for n in range(15)] [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]

Implementasi fibonacci_of() ini cukup minim. Ia menggunakan pembongkaran berulang untuk menghitung angka Fibonacci selama perulangan, yang cukup efisien dalam hal memori. Namun, setiap kali Cnda memanggil fungsi dengan nilai n yang berbeda, ia harus menghitung ulang urutannya lagi. Untuk memperbaikinya, Cnda dapat menggunakan penutupan dan membuat fungsi Cnda mengingat nilai yang sudah dihitung di antara panggilan. Silahkan dan cobalah!

Kesimpulan

Deret Fibonacci dapat membantu Cnda meningkatkan pemahaman Cnda tentang rekursi. Dalam tutorial ini, Cnda telah mempelajari apa itu Deret Fibonacci. Cnda juga telah mempelajari beberapa algoritme umum untuk menghasilkan urutan dan cara menerjemahkannya ke dalam kode Python.

Deret Fibonacci dapat menjadi batu loncatan dan titik masuk yang sangat baik ke dalam dunia rekursi, yang merupakan keterampilan mendasar yang harus dimiliki sebagai seorang programmer.

Dalam tutorial ini, Cnda mempelajari cara:

Hasilkan deret Fibonacci menggunakan algoritme rekursif

Optimalkan algoritme Fibonacci rekursif Cnda menggunakan memoisasi

Hasilkan deret Fibonacci menggunakan algoritme berulang

Cnda juga telah memZZZisualisasikan algoritme rekursif yang dimemo untuk mendapatkan pemahaman yang lebih baik tentang cara kerjanya di balik layar. Untuk melakukannya, Cnda menggunakan diagram tumpukan panggilan.

Setelah Cnda menguasai konsep-konsep dalam tutorial ini, keterampilan pemrograman Python Cnda akan meningkat seiring dengan pemikiran algoritmik rekursif Cnda.