If youâve ever wondered how to implement Fibonacci numbers using recursion, youâre in the right place. This classic programming problem is a perfect way to understand recursive functions, and Iâll show you how to solve it in seven popular programming languages: C, C++, Java, Python, PHP, Go, and Ruby.
What Are Fibonacci Numbers?
The Fibonacci sequence is a series of numbers where each number is the sum of the two preceding ones. It starts with 0 and 1, so the sequence goes: 0, 1, 1, 2, 3, 5, 8, 13, 21, and so on. This pattern appears everywhere in nature, from flower petals to spiral galaxies.
The mathematical formula is simple: F(n) = F(n-1) + F(n-2), with base cases F(0) = 0 and F(1) = 1. Recursion is a natural fit for this problem because each Fibonacci number depends on previous ones.
Implementation in C
Letâs start with C, one of the most fundamental programming languages. Hereâs how you can implement Fibonacci recursion in C:
#include <stdio.h>
int fibonacci(int n) {
if (n <= 1) {
return n;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}
int main() {
int num = 10;
printf("Fibonacci of %d is %d\n", num, fibonacci(num));
return 0;
}
The function checks if n is 0 or 1 (base cases), then returns n. Otherwise, it recursively calls itself with n-1 and n-2, adding the results together.
Implementation in C++
C++ is similar to C but with object-oriented features. Hereâs the recursive Fibonacci in C++:
#include <iostream>
using namespace std;
int fibonacci(int n) {
if (n <= 1) {
return n;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}
int main() {
int num = 10;
cout << "Fibonacci of " << num << " is " << fibonacci(num) << endl;
return 0;
}
The logic is identical to C, but we use cout for output instead of printf. The recursive structure remains the same, making it easy to transition between these languages.
Implementation in Java
Java brings strong typing and object-oriented programming to the table. Hereâs the Fibonacci implementation:
public class Fibonacci {
public static int fibonacci(int n) {
if (n <= 1) {
return n;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}
public static void main(String[] args) {
int num = 10;
System.out.println("Fibonacci of " + num + " is " + fibonacci(num));
}
}
In Java, we define the function as static so it can be called from the main method without creating an instance. The recursive logic stays consistent across all languages.
Implementation in Python
Pythonâs clean syntax makes recursive functions incredibly readable. Hereâs the Fibonacci implementation:
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
num = 10
print(f"Fibonacci of {num} is {fibonacci(num)}")
Python doesnât need semicolons or curly braces, which makes the code look cleaner. The function definition uses def, and the rest follows the same recursive pattern.
Implementation in PHP
PHP is widely used for web development, and it handles recursion just as well. Hereâs how:
<?php
function fibonacci($n) {
if ($n <= 1) {
return $n;
}
return fibonacci($n - 1) + fibonacci($n - 2);
}
$num = 10;
echo "Fibonacci of $num is " . fibonacci($num) . "\n";
?>
PHP requires the dollar sign ($) before variable names, and functions are defined with the function keyword. The recursive structure is identical to other languages.
Implementation in Go
Go (Golang) is known for its simplicity and performance. Hereâs the recursive Fibonacci:
package main
import "fmt"
func fibonacci(n int) int {
if n <= 1 {
return n
}
return fibonacci(n-1) + fibonacci(n-2)
}
func main() {
num := 10
fmt.Printf("Fibonacci of %d is %d\n", num, fibonacci(num))
}
Go uses explicit type declarations (int) and the := operator for variable initialization. The package and import statements are required for Go programs.
Implementation in Ruby
Ruby is elegant and expressive, perfect for recursive functions. Hereâs the Fibonacci code:
def fibonacci(n)
if n <= 1
return n
end
return fibonacci(n - 1) + fibonacci(n - 2)
end
num = 10
puts "Fibonacci of #{num} is #{fibonacci(num)}"
Ruby uses end to close function definitions and if statements. The #{} syntax allows string interpolation, making output statements cleaner.
While recursion is elegant, itâs not the most efficient approach for Fibonacci numbers. The recursive solution has exponential time complexity O(2^n) because it recalculates the same values multiple times. For example, calculating F(5) requires calculating F(4) and F(3), but F(4) also calculates F(3) again.
For larger numbers, youâll want to use dynamic programming or memoization to cache results. However, for learning recursion and understanding how it works, this implementation is perfect.
Conclusion
Recursion is a powerful programming technique, and Fibonacci numbers provide an excellent example of how it works. Weâve explored implementations in C, C++, Java, Python, PHP, Go, and Ruby, and while the syntax differs, the core logic remains the same: define base cases and let the function call itself with smaller inputs.
Try running these examples in your preferred language, experiment with different input values, and see how recursion unfolds. Understanding recursion deeply will make you a better programmer, even if you donât always use it in production code.
āĻāĻĒāĻ¨āĻŋ āĻ¯āĻĻāĻŋ āĻāĻāĻ¨āĻ āĻā§āĻŦā§ āĻĨāĻžāĻā§āĻ¨ āĻā§āĻāĻžāĻŦā§ āĻ°āĻŋāĻāĻžāĻ°ā§āĻļāĻ¨ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻāĻ°ā§ āĻĢāĻŋāĻŦā§āĻ¨āĻžāĻāĻŋ āĻ¸āĻāĻā§āĻ¯āĻž āĻŦāĻžāĻ¸ā§āĻ¤āĻŦāĻžāĻ¯āĻŧāĻ¨ āĻāĻ°āĻ¤ā§ āĻšāĻ¯āĻŧ, āĻ¤āĻžāĻšāĻ˛ā§ āĻāĻĒāĻ¨āĻŋ āĻ¸āĻ āĻŋāĻ āĻāĻžāĻ¯āĻŧāĻāĻžāĻ¯āĻŧ āĻāĻā§āĻ¨āĨ¤ āĻāĻ āĻā§āĻ˛āĻžāĻ¸āĻŋāĻ āĻĒā§āĻ°ā§āĻā§āĻ°āĻžāĻŽāĻŋāĻ āĻ¸āĻŽāĻ¸ā§āĻ¯āĻžāĻāĻŋ āĻ°āĻŋāĻāĻžāĻ°ā§āĻ¸āĻŋāĻ āĻĢāĻžāĻāĻļāĻ¨ āĻŦā§āĻāĻžāĻ° āĻāĻ¨ā§āĻ¯ āĻāĻāĻāĻŋ āĻ¨āĻŋāĻā§āĻāĻ¤ āĻāĻĒāĻžāĻ¯āĻŧ, āĻāĻŦāĻ āĻāĻŽāĻŋ āĻāĻĒāĻ¨āĻžāĻā§ āĻĻā§āĻāĻžāĻŦ āĻā§āĻāĻžāĻŦā§ āĻ¸āĻžāĻ¤āĻāĻŋ āĻāĻ¨āĻĒā§āĻ°āĻŋāĻ¯āĻŧ āĻĒā§āĻ°ā§āĻā§āĻ°āĻžāĻŽāĻŋāĻ āĻāĻžāĻˇāĻžāĻ¯āĻŧ āĻāĻāĻŋ āĻ¸āĻŽāĻžāĻ§āĻžāĻ¨ āĻāĻ°āĻ¤ā§ āĻšāĻ¯āĻŧ: C, C++, Java, Python, PHP, Go āĻāĻŦāĻ RubyāĨ¤
āĻĢāĻŋāĻŦā§āĻ¨āĻžāĻāĻŋ āĻ¸āĻāĻā§āĻ¯āĻž āĻā§?
āĻĢāĻŋāĻŦā§āĻ¨āĻžāĻāĻŋ āĻā§āĻ°āĻŽ āĻšāĻ˛ āĻāĻŽāĻ¨ āĻāĻāĻāĻŋ āĻ¸āĻāĻā§āĻ¯āĻžāĻ° āĻ¸āĻŋāĻ°āĻŋāĻ āĻ¯ā§āĻāĻžāĻ¨ā§ āĻĒā§āĻ°āĻ¤āĻŋāĻāĻŋ āĻ¸āĻāĻā§āĻ¯āĻž āĻ¤āĻžāĻ° āĻāĻā§āĻ° āĻĻā§āĻāĻŋ āĻ¸āĻāĻā§āĻ¯āĻžāĻ° āĻ¯ā§āĻāĻĢāĻ˛āĨ¤ āĻāĻāĻŋ ā§Ļ āĻāĻŦāĻ ā§§ āĻĻāĻŋāĻ¯āĻŧā§ āĻļā§āĻ°ā§ āĻšāĻ¯āĻŧ, āĻ¤āĻžāĻ āĻā§āĻ°āĻŽāĻāĻŋ āĻšāĻ¯āĻŧ: ā§Ļ, ā§§, ā§§, ā§¨, ā§Š, ā§Ģ, ā§Ž, ā§§ā§Š, ā§¨ā§§, āĻāĻŦāĻ āĻāĻāĻžāĻŦā§ āĻāĻ˛āĻ¤ā§ āĻĨāĻžāĻā§āĨ¤ āĻāĻ āĻĒā§āĻ¯āĻžāĻāĻžāĻ°ā§āĻ¨āĻāĻŋ āĻĒā§āĻ°āĻā§āĻ¤āĻŋāĻ¤ā§ āĻ¸āĻ°ā§āĻŦāĻ¤ā§āĻ° āĻĻā§āĻāĻž āĻ¯āĻžāĻ¯āĻŧ, āĻĢā§āĻ˛ā§āĻ° āĻĒāĻžāĻĒāĻĄāĻŧāĻŋ āĻĨā§āĻā§ āĻļā§āĻ°ā§ āĻāĻ°ā§ āĻ¸āĻ°ā§āĻĒāĻŋāĻ˛ āĻā§āĻ¯āĻžāĻ˛āĻžāĻā§āĻ¸āĻŋ āĻĒāĻ°ā§āĻ¯āĻ¨ā§āĻ¤āĨ¤
āĻāĻžāĻŖāĻŋāĻ¤āĻŋāĻ āĻ¸ā§āĻ¤ā§āĻ°āĻāĻŋ āĻ¸āĻšāĻ: F(n) = F(n-1) + F(n-2), āĻŦā§āĻ¸ āĻā§āĻ¸ F(0) = 0 āĻāĻŦāĻ F(1) = 1 āĻ¸āĻšāĨ¤ āĻ°āĻŋāĻāĻžāĻ°ā§āĻļāĻ¨ āĻāĻ āĻ¸āĻŽāĻ¸ā§āĻ¯āĻžāĻ° āĻāĻ¨ā§āĻ¯ āĻāĻāĻāĻŋ āĻ¸ā§āĻŦāĻžāĻāĻžāĻŦāĻŋāĻ āĻĢāĻŋāĻ āĻāĻžāĻ°āĻŖ āĻĒā§āĻ°āĻ¤āĻŋāĻāĻŋ āĻĢāĻŋāĻŦā§āĻ¨āĻžāĻāĻŋ āĻ¸āĻāĻā§āĻ¯āĻž āĻĒā§āĻ°ā§āĻŦāĻŦāĻ°ā§āĻ¤ā§ āĻ¸āĻāĻā§āĻ¯āĻžāĻā§āĻ˛āĻŋāĻ° āĻāĻĒāĻ° āĻ¨āĻŋāĻ°ā§āĻāĻ° āĻāĻ°ā§āĨ¤
C-āĻ¤ā§ āĻŦāĻžāĻ¸ā§āĻ¤āĻŦāĻžāĻ¯āĻŧāĻ¨
āĻāĻ˛ā§āĻ¨ C āĻĻāĻŋāĻ¯āĻŧā§ āĻļā§āĻ°ā§ āĻāĻ°āĻŋ, āĻ¯āĻž āĻ¸āĻŦāĻā§āĻ¯āĻŧā§ āĻŽā§āĻ˛āĻŋāĻ āĻĒā§āĻ°ā§āĻā§āĻ°āĻžāĻŽāĻŋāĻ āĻāĻžāĻˇāĻžāĻā§āĻ˛āĻŋāĻ° āĻāĻāĻāĻŋāĨ¤ āĻāĻāĻžāĻ¨ā§ C-āĻ¤ā§ āĻĢāĻŋāĻŦā§āĻ¨āĻžāĻāĻŋ āĻ°āĻŋāĻāĻžāĻ°ā§āĻļāĻ¨ āĻā§āĻāĻžāĻŦā§ āĻŦāĻžāĻ¸ā§āĻ¤āĻŦāĻžāĻ¯āĻŧāĻ¨ āĻāĻ°āĻŦā§āĻ¨:
#include <stdio.h>
int fibonacci(int n) {
if (n <= 1) {
return n;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}
int main() {
int num = 10;
printf("Fibonacci of %d is %d\n", num, fibonacci(num));
return 0;
}
āĻĢāĻžāĻāĻļāĻ¨āĻāĻŋ āĻĒāĻ°ā§āĻā§āĻˇāĻž āĻāĻ°ā§ n āĻ¯āĻĻāĻŋ ā§Ļ āĻŦāĻž ā§§ āĻšāĻ¯āĻŧ (āĻŦā§āĻ¸ āĻā§āĻ¸), āĻ¤āĻžāĻšāĻ˛ā§ n āĻ°āĻŋāĻāĻžāĻ°ā§āĻ¨ āĻāĻ°ā§āĨ¤ āĻ
āĻ¨ā§āĻ¯āĻĨāĻžāĻ¯āĻŧ, āĻāĻāĻŋ n-1 āĻāĻŦāĻ n-2 āĻĻāĻŋāĻ¯āĻŧā§ āĻ¨āĻŋāĻā§āĻā§ āĻ°āĻŋāĻāĻžāĻ°ā§āĻ¸āĻŋāĻāĻāĻžāĻŦā§ āĻāĻ˛ āĻāĻ°ā§ āĻāĻŦāĻ āĻĢāĻ˛āĻžāĻĢāĻ˛ āĻ¯ā§āĻ āĻāĻ°ā§āĨ¤
C++-āĻ āĻŦāĻžāĻ¸ā§āĻ¤āĻŦāĻžāĻ¯āĻŧāĻ¨
C++ C-āĻ° āĻŽāĻ¤ā§āĻ āĻāĻŋāĻ¨ā§āĻ¤ā§ āĻ
āĻŦāĻā§āĻā§āĻ-āĻāĻ°āĻŋāĻ¯āĻŧā§āĻ¨ā§āĻā§āĻĄ āĻŦā§āĻļāĻŋāĻˇā§āĻā§āĻ¯ āĻ¸āĻšāĨ¤ āĻāĻāĻžāĻ¨ā§ C++-āĻ āĻ°āĻŋāĻāĻžāĻ°ā§āĻ¸āĻŋāĻ āĻĢāĻŋāĻŦā§āĻ¨āĻžāĻāĻŋ:
#include <iostream>
using namespace std;
int fibonacci(int n) {
if (n <= 1) {
return n;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}
int main() {
int num = 10;
cout << "Fibonacci of " << num << " is " << fibonacci(num) << endl;
return 0;
}
āĻ˛āĻāĻŋāĻāĻāĻŋ C-āĻ° āĻŽāĻ¤ā§āĻ, āĻāĻŋāĻ¨ā§āĻ¤ā§ āĻāĻŽāĻ°āĻž printf-āĻāĻ° āĻĒāĻ°āĻŋāĻŦāĻ°ā§āĻ¤ā§ cout āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻāĻ°āĻŋ āĻāĻāĻāĻĒā§āĻā§āĻ° āĻāĻ¨ā§āĻ¯āĨ¤ āĻ°āĻŋāĻāĻžāĻ°ā§āĻ¸āĻŋāĻ āĻ¸ā§āĻā§āĻ°āĻžāĻāĻāĻžāĻ° āĻāĻāĻ āĻĨāĻžāĻā§, āĻ¯āĻž āĻāĻ āĻāĻžāĻˇāĻžāĻā§āĻ˛āĻŋāĻ° āĻŽāĻ§ā§āĻ¯ā§ āĻ°ā§āĻĒāĻžāĻ¨ā§āĻ¤āĻ° āĻ¸āĻšāĻ āĻāĻ°ā§ āĻ¤ā§āĻ˛ā§āĨ¤
Java-āĻ¤ā§ āĻŦāĻžāĻ¸ā§āĻ¤āĻŦāĻžāĻ¯āĻŧāĻ¨
Java āĻļāĻā§āĻ¤āĻŋāĻļāĻžāĻ˛ā§ āĻāĻžāĻāĻĒāĻŋāĻ āĻāĻŦāĻ āĻ
āĻŦāĻā§āĻā§āĻ-āĻāĻ°āĻŋāĻ¯āĻŧā§āĻ¨ā§āĻā§āĻĄ āĻĒā§āĻ°ā§āĻā§āĻ°āĻžāĻŽāĻŋāĻ āĻ¨āĻŋāĻ¯āĻŧā§ āĻāĻ¸ā§āĨ¤ āĻāĻāĻžāĻ¨ā§ āĻĢāĻŋāĻŦā§āĻ¨āĻžāĻāĻŋ āĻŦāĻžāĻ¸ā§āĻ¤āĻŦāĻžāĻ¯āĻŧāĻ¨:
public class Fibonacci {
public static int fibonacci(int n) {
if (n <= 1) {
return n;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}
public static void main(String[] args) {
int num = 10;
System.out.println("Fibonacci of " + num + " is " + fibonacci(num));
}
}
Java-āĻ¤ā§, āĻāĻŽāĻ°āĻž āĻĢāĻžāĻāĻļāĻ¨āĻāĻŋāĻā§ static āĻšāĻŋāĻ¸ā§āĻŦā§ āĻĄāĻŋāĻĢāĻžāĻāĻ¨ āĻāĻ°āĻŋ āĻ¯āĻžāĻ¤ā§ āĻāĻāĻŋ main āĻŽā§āĻĨāĻĄ āĻĨā§āĻā§ āĻāĻ¨āĻ¸ā§āĻā§āĻ¯āĻžāĻ¨ā§āĻ¸ āĻ¤ā§āĻ°āĻŋ āĻ¨āĻž āĻāĻ°ā§ āĻāĻ˛ āĻāĻ°āĻž āĻ¯āĻžāĻ¯āĻŧāĨ¤ āĻ°āĻŋāĻāĻžāĻ°ā§āĻ¸āĻŋāĻ āĻ˛āĻāĻŋāĻ āĻ¸āĻŦ āĻāĻžāĻˇāĻžāĻ¯āĻŧ āĻ¸āĻžāĻŽāĻā§āĻāĻ¸ā§āĻ¯āĻĒā§āĻ°ā§āĻŖ āĻĨāĻžāĻā§āĨ¤
Python-āĻ āĻŦāĻžāĻ¸ā§āĻ¤āĻŦāĻžāĻ¯āĻŧāĻ¨
Python-āĻāĻ° āĻĒāĻ°āĻŋāĻˇā§āĻāĻžāĻ° āĻ¸āĻŋāĻ¨āĻā§āĻ¯āĻžāĻā§āĻ¸ āĻ°āĻŋāĻāĻžāĻ°ā§āĻ¸āĻŋāĻ āĻĢāĻžāĻāĻļāĻ¨āĻā§āĻ˛āĻŋāĻā§ āĻ
āĻŦāĻŋāĻļā§āĻŦāĻžāĻ¸ā§āĻ¯āĻāĻžāĻŦā§ āĻĒāĻžāĻ āĻ¯ā§āĻā§āĻ¯ āĻāĻ°ā§ āĻ¤ā§āĻ˛ā§āĨ¤ āĻāĻāĻžāĻ¨ā§ āĻĢāĻŋāĻŦā§āĻ¨āĻžāĻāĻŋ āĻŦāĻžāĻ¸ā§āĻ¤āĻŦāĻžāĻ¯āĻŧāĻ¨:
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
num = 10
print(f"Fibonacci of {num} is {fibonacci(num)}")
Python-āĻ āĻ¸ā§āĻŽāĻŋāĻā§āĻ˛āĻ¨ āĻŦāĻž āĻāĻžāĻ°ā§āĻ˛āĻŋ āĻŦā§āĻ°ā§āĻ¸ā§āĻ° āĻĒā§āĻ°āĻ¯āĻŧā§āĻāĻ¨ āĻ¨ā§āĻ, āĻ¯āĻž āĻā§āĻĄāĻā§ āĻāĻ°āĻ āĻĒāĻ°āĻŋāĻˇā§āĻāĻžāĻ° āĻĻā§āĻāĻžāĻ¯āĻŧāĨ¤ āĻĢāĻžāĻāĻļāĻ¨ āĻĄā§āĻĢāĻŋāĻ¨āĻŋāĻļāĻ¨ā§ def āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻāĻ°āĻž āĻšāĻ¯āĻŧ āĻāĻŦāĻ āĻŦāĻžāĻāĻŋāĻāĻž āĻāĻāĻ āĻ°āĻŋāĻāĻžāĻ°ā§āĻ¸āĻŋāĻ āĻĒā§āĻ¯āĻžāĻāĻžāĻ°ā§āĻ¨ āĻ
āĻ¨ā§āĻ¸āĻ°āĻŖ āĻāĻ°ā§āĨ¤
PHP-āĻ¤ā§ āĻŦāĻžāĻ¸ā§āĻ¤āĻŦāĻžāĻ¯āĻŧāĻ¨
PHP āĻāĻ¯āĻŧā§āĻŦ āĻĄā§āĻā§āĻ˛āĻĒāĻŽā§āĻ¨ā§āĻā§āĻ° āĻāĻ¨ā§āĻ¯ āĻŦā§āĻ¯āĻžāĻĒāĻāĻāĻžāĻŦā§ āĻŦā§āĻ¯āĻŦāĻšā§āĻ¤ āĻšāĻ¯āĻŧ, āĻāĻŦāĻ āĻāĻāĻŋ āĻ°āĻŋāĻāĻžāĻ°ā§āĻļāĻ¨āĻ āĻāĻžāĻ˛ā§āĻāĻžāĻŦā§ āĻĒāĻ°āĻŋāĻāĻžāĻ˛āĻ¨āĻž āĻāĻ°ā§āĨ¤ āĻāĻāĻžāĻ¨ā§ āĻā§āĻāĻžāĻŦā§:
<?php
function fibonacci($n) {
if ($n <= 1) {
return $n;
}
return fibonacci($n - 1) + fibonacci($n - 2);
}
$num = 10;
echo "Fibonacci of $num is " . fibonacci($num) . "\n";
?>
PHP-āĻ¤ā§ āĻā§āĻ°āĻŋāĻ¯āĻŧā§āĻŦāĻ˛ āĻ¨āĻžāĻŽā§āĻ° āĻāĻā§ āĻĄāĻ˛āĻžāĻ° āĻāĻŋāĻšā§āĻ¨ ($) āĻĒā§āĻ°āĻ¯āĻŧā§āĻāĻ¨, āĻāĻŦāĻ āĻĢāĻžāĻāĻļāĻ¨ function āĻā§āĻāĻ¯āĻŧāĻžāĻ°ā§āĻĄ āĻĻāĻŋāĻ¯āĻŧā§ āĻĄāĻŋāĻĢāĻžāĻāĻ¨ āĻāĻ°āĻž āĻšāĻ¯āĻŧāĨ¤ āĻ°āĻŋāĻāĻžāĻ°ā§āĻ¸āĻŋāĻ āĻ¸ā§āĻā§āĻ°āĻžāĻāĻāĻžāĻ° āĻ
āĻ¨ā§āĻ¯ āĻāĻžāĻˇāĻžāĻ° āĻŽāĻ¤ā§āĻāĨ¤
Go-āĻ¤ā§ āĻŦāĻžāĻ¸ā§āĻ¤āĻŦāĻžāĻ¯āĻŧāĻ¨
Go (Golang) āĻ¤āĻžāĻ° āĻ¸āĻ°āĻ˛āĻ¤āĻž āĻāĻŦāĻ āĻĒāĻžāĻ°āĻĢāĻ°āĻŽā§āĻ¯āĻžāĻ¨ā§āĻ¸ā§āĻ° āĻāĻ¨ā§āĻ¯ āĻĒāĻ°āĻŋāĻāĻŋāĻ¤āĨ¤ āĻāĻāĻžāĻ¨ā§ āĻ°āĻŋāĻāĻžāĻ°ā§āĻ¸āĻŋāĻ āĻĢāĻŋāĻŦā§āĻ¨āĻžāĻāĻŋ:
package main
import "fmt"
func fibonacci(n int) int {
if n <= 1 {
return n
}
return fibonacci(n-1) + fibonacci(n-2)
}
func main() {
num := 10
fmt.Printf("Fibonacci of %d is %d\n", num, fibonacci(num))
}
Go āĻ¸ā§āĻĒāĻˇā§āĻ āĻāĻžāĻāĻĒ āĻĄāĻŋāĻā§āĻ˛ā§āĻ¯āĻŧāĻžāĻ°ā§āĻļāĻ¨ (int) āĻāĻŦāĻ := āĻ
āĻĒāĻžāĻ°ā§āĻāĻ° āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻāĻ°ā§ āĻā§āĻ°āĻŋāĻ¯āĻŧā§āĻŦāĻ˛ āĻāĻ¨āĻŋāĻļāĻŋāĻ¯āĻŧāĻžāĻ˛āĻžāĻāĻā§āĻļāĻ¨ā§āĻ° āĻāĻ¨ā§āĻ¯āĨ¤ package āĻāĻŦāĻ import āĻ¸ā§āĻā§āĻāĻŽā§āĻ¨ā§āĻ Go āĻĒā§āĻ°ā§āĻā§āĻ°āĻžāĻŽā§āĻ° āĻāĻ¨ā§āĻ¯ āĻĒā§āĻ°āĻ¯āĻŧā§āĻāĻ¨ā§āĻ¯āĻŧāĨ¤
Ruby-āĻ¤ā§ āĻŦāĻžāĻ¸ā§āĻ¤āĻŦāĻžāĻ¯āĻŧāĻ¨
Ruby āĻŽāĻžāĻ°ā§āĻāĻŋāĻ¤ āĻāĻŦāĻ āĻĒā§āĻ°āĻāĻžāĻļāĻ, āĻ°āĻŋāĻāĻžāĻ°ā§āĻ¸āĻŋāĻ āĻĢāĻžāĻāĻļāĻ¨ā§āĻ° āĻāĻ¨ā§āĻ¯ āĻ¨āĻŋāĻā§āĻāĻ¤āĨ¤ āĻāĻāĻžāĻ¨ā§ āĻĢāĻŋāĻŦā§āĻ¨āĻžāĻāĻŋ āĻā§āĻĄ:
def fibonacci(n)
if n <= 1
return n
end
return fibonacci(n - 1) + fibonacci(n - 2)
end
num = 10
puts "Fibonacci of #{num} is #{fibonacci(num)}"
Ruby āĻĢāĻžāĻāĻļāĻ¨ āĻĄā§āĻĢāĻŋāĻ¨āĻŋāĻļāĻ¨ āĻāĻŦāĻ if āĻ¸ā§āĻā§āĻāĻŽā§āĻ¨ā§āĻ āĻŦāĻ¨ā§āĻ§ āĻāĻ°āĻ¤ā§ end āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻāĻ°ā§āĨ¤ #{} āĻ¸āĻŋāĻ¨āĻā§āĻ¯āĻžāĻā§āĻ¸ āĻ¸ā§āĻā§āĻ°āĻŋāĻ āĻāĻ¨ā§āĻāĻžāĻ°āĻĒā§āĻ˛ā§āĻļāĻ¨ āĻ
āĻ¨ā§āĻŽāĻ¤āĻŋ āĻĻā§āĻ¯āĻŧ, āĻ¯āĻž āĻāĻāĻāĻĒā§āĻ āĻ¸ā§āĻā§āĻāĻŽā§āĻ¨ā§āĻ āĻĒāĻ°āĻŋāĻˇā§āĻāĻžāĻ° āĻāĻ°ā§āĨ¤
āĻĒāĻžāĻ°āĻĢāĻ°āĻŽā§āĻ¯āĻžāĻ¨ā§āĻ¸ āĻā§āĻ°ā§āĻĄ-āĻ
āĻĢ āĻŦā§āĻāĻž
āĻ¯āĻĻāĻŋāĻ āĻ°āĻŋāĻāĻžāĻ°ā§āĻļāĻ¨ āĻŽāĻžāĻ°ā§āĻāĻŋāĻ¤, āĻāĻāĻŋ āĻĢāĻŋāĻŦā§āĻ¨āĻžāĻāĻŋ āĻ¸āĻāĻā§āĻ¯āĻžāĻ° āĻāĻ¨ā§āĻ¯ āĻ¸āĻŦāĻā§āĻ¯āĻŧā§ āĻĻāĻā§āĻˇ āĻĒāĻĻā§āĻ§āĻ¤āĻŋ āĻ¨āĻ¯āĻŧāĨ¤ āĻ°āĻŋāĻāĻžāĻ°ā§āĻ¸āĻŋāĻ āĻ¸āĻŽāĻžāĻ§āĻžāĻ¨ā§āĻ° āĻāĻā§āĻ¸āĻĒā§āĻ¨ā§āĻ¨āĻļāĻŋāĻ¯āĻŧāĻžāĻ˛ āĻāĻžāĻāĻŽ āĻāĻŽāĻĒā§āĻ˛ā§āĻā§āĻ¸āĻŋāĻāĻŋ O(2^n) āĻāĻā§ āĻāĻžāĻ°āĻŖ āĻāĻāĻŋ āĻāĻāĻ āĻŽāĻžāĻ¨ āĻŦāĻžāĻ°āĻŦāĻžāĻ° āĻĒā§āĻ¨āĻ°āĻžāĻ¯āĻŧ āĻāĻŖāĻ¨āĻž āĻāĻ°ā§āĨ¤ āĻāĻĻāĻžāĻšāĻ°āĻŖāĻ¸ā§āĻŦāĻ°ā§āĻĒ, F(5) āĻāĻŖāĻ¨āĻž āĻāĻ°āĻ¤ā§ F(4) āĻāĻŦāĻ F(3) āĻāĻŖāĻ¨āĻž āĻāĻ°āĻ¤ā§ āĻšāĻ¯āĻŧ, āĻāĻŋāĻ¨ā§āĻ¤ā§ F(4) āĻāĻŦāĻžāĻ° F(3) āĻāĻŖāĻ¨āĻž āĻāĻ°ā§āĨ¤
āĻŦāĻĄāĻŧ āĻ¸āĻāĻā§āĻ¯āĻžāĻ° āĻāĻ¨ā§āĻ¯, āĻāĻĒāĻ¨āĻŋ āĻĢāĻ˛āĻžāĻĢāĻ˛ āĻā§āĻ¯āĻžāĻļ āĻāĻ°āĻ¤ā§ āĻĄāĻžāĻ¯āĻŧāĻ¨āĻžāĻŽāĻŋāĻ āĻĒā§āĻ°ā§āĻā§āĻ°āĻžāĻŽāĻŋāĻ āĻŦāĻž āĻŽā§āĻŽā§āĻāĻā§āĻļāĻ¨ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻāĻ°āĻ¤ā§ āĻāĻžāĻāĻŦā§āĻ¨āĨ¤ āĻ¤āĻŦā§, āĻ°āĻŋāĻāĻžāĻ°ā§āĻļāĻ¨ āĻļā§āĻāĻžāĻ° āĻāĻŦāĻ āĻāĻāĻŋ āĻā§āĻāĻžāĻŦā§ āĻāĻžāĻ āĻāĻ°ā§ āĻ¤āĻž āĻŦā§āĻāĻžāĻ° āĻāĻ¨ā§āĻ¯, āĻāĻ āĻŦāĻžāĻ¸ā§āĻ¤āĻŦāĻžāĻ¯āĻŧāĻ¨āĻāĻŋ āĻ¨āĻŋāĻā§āĻāĻ¤āĨ¤
āĻāĻĒāĻ¸āĻāĻšāĻžāĻ°
āĻ°āĻŋāĻāĻžāĻ°ā§āĻļāĻ¨ āĻāĻāĻāĻŋ āĻļāĻā§āĻ¤āĻŋāĻļāĻžāĻ˛ā§ āĻĒā§āĻ°ā§āĻā§āĻ°āĻžāĻŽāĻŋāĻ āĻā§āĻļāĻ˛, āĻāĻŦāĻ āĻĢāĻŋāĻŦā§āĻ¨āĻžāĻāĻŋ āĻ¸āĻāĻā§āĻ¯āĻž āĻāĻāĻŋ āĻā§āĻāĻžāĻŦā§ āĻāĻžāĻ āĻāĻ°ā§ āĻ¤āĻžāĻ° āĻāĻāĻāĻŋ āĻāĻŽā§āĻāĻžāĻ° āĻāĻĻāĻžāĻšāĻ°āĻŖ āĻĒā§āĻ°āĻĻāĻžāĻ¨ āĻāĻ°ā§āĨ¤ āĻāĻŽāĻ°āĻž C, C++, Java, Python, PHP, Go āĻāĻŦāĻ Ruby-āĻ¤ā§ āĻŦāĻžāĻ¸ā§āĻ¤āĻŦāĻžāĻ¯āĻŧāĻ¨ āĻ
āĻ¨ā§āĻŦā§āĻˇāĻŖ āĻāĻ°ā§āĻāĻŋ, āĻāĻŦāĻ āĻ¯āĻĻāĻŋāĻ āĻ¸āĻŋāĻ¨āĻā§āĻ¯āĻžāĻā§āĻ¸ āĻāĻŋāĻ¨ā§āĻ¨, āĻŽā§āĻ˛ āĻ˛āĻāĻŋāĻ āĻāĻāĻ āĻĨāĻžāĻā§: āĻŦā§āĻ¸ āĻā§āĻ¸ āĻĄāĻŋāĻĢāĻžāĻāĻ¨ āĻāĻ°ā§āĻ¨ āĻāĻŦāĻ āĻĢāĻžāĻāĻļāĻ¨āĻāĻŋāĻā§ āĻā§āĻ āĻāĻ¨āĻĒā§āĻ āĻĻāĻŋāĻ¯āĻŧā§ āĻ¨āĻŋāĻā§āĻā§ āĻāĻ˛ āĻāĻ°āĻ¤ā§ āĻĻāĻŋāĻ¨āĨ¤
āĻāĻĒāĻ¨āĻžāĻ° āĻĒāĻāĻ¨ā§āĻĻā§āĻ° āĻāĻžāĻˇāĻžāĻ¯āĻŧ āĻāĻ āĻāĻĻāĻžāĻšāĻ°āĻŖāĻā§āĻ˛āĻŋ āĻāĻžāĻ˛āĻžāĻ¨ā§āĻ° āĻā§āĻˇā§āĻāĻž āĻāĻ°ā§āĻ¨, āĻŦāĻŋāĻāĻŋāĻ¨ā§āĻ¨ āĻāĻ¨āĻĒā§āĻ āĻŽāĻžāĻ¨ āĻ¨āĻŋāĻ¯āĻŧā§ āĻĒāĻ°ā§āĻā§āĻˇāĻž āĻāĻ°ā§āĻ¨ āĻāĻŦāĻ āĻĻā§āĻā§āĻ¨ āĻā§āĻāĻžāĻŦā§ āĻ°āĻŋāĻāĻžāĻ°ā§āĻļāĻ¨ āĻāĻ¨ā§āĻŽā§āĻāĻŋāĻ¤ āĻšāĻ¯āĻŧāĨ¤ āĻ°āĻŋāĻāĻžāĻ°ā§āĻļāĻ¨ āĻāĻā§āĻ°āĻāĻžāĻŦā§ āĻŦā§āĻāĻž āĻāĻĒāĻ¨āĻžāĻā§ āĻāĻāĻāĻ¨ āĻāĻžāĻ˛ā§ āĻĒā§āĻ°ā§āĻā§āĻ°āĻžāĻŽāĻžāĻ° āĻŦāĻžāĻ¨āĻžāĻŦā§, āĻāĻŽāĻ¨āĻāĻŋ āĻāĻĒāĻ¨āĻŋ āĻ¸āĻŦāĻ¸āĻŽāĻ¯āĻŧ āĻĒā§āĻ°ā§āĻĄāĻžāĻāĻļāĻ¨ āĻā§āĻĄā§ āĻāĻāĻŋ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻ¨āĻž āĻāĻ°āĻ˛ā§āĻāĨ¤
]]>
