add recursive fibonacci and reverse string

Author: sangtrandev00

src/algorithm/recursion/recursion-fibonacci.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from "bun:test";
+import { fibonacciIterative, fibonacciRecursive } from "./recursion-fibonacci";
+
+describe('Fibonacci Sequence', () => {
+    // Test cases for both iterative and recursive implementations
+    const testCases = [
+        { input: 0, expected: 0 },
+        { input: 1, expected: 1 },
+        { input: 2, expected: 1 },
+        { input: 3, expected: 2 },
+        { input: 4, expected: 3 },
+        { input: 5, expected: 5 },
+        { input: 6, expected: 8 },
+        { input: 7, expected: 13 },
+        { input: 8, expected: 21 },
+    ];
+
+    describe('Iterative Fibonacci', () => {
+        it.each(testCases)('should return $expected for input $input', ({ input, expected }) => {
+            expect(fibonacciIterative(input)).toBe(expected);
+        });
+
+        it('should handle negative input', () => {
+            expect(fibonacciIterative(-1)).toBe(-1);
+            expect(fibonacciIterative(-5)).toBe(-1);
+        });
+    });
+
+    describe('Recursive Fibonacci', () => {
+        it.each(testCases)('should return $expected for input $input', ({ input, expected }) => {
+            expect(fibonacciRecursive(input)).toBe(expected);
+        });
+
+        it('should handle negative input', () => {
+            expect(fibonacciRecursive(-1)).toBe(-1);
+            expect(fibonacciRecursive(-5)).toBe(-1);
+        });
+
+        // Note: Be cautious with large inputs due to recursive call overhead
+        it('should handle larger inputs', () => {
+            expect(fibonacciRecursive(10)).toBe(55);
+        });
+    });
+
+    // Performance and edge case tests
+    describe('Performance and Edge Cases', () => {
+        it('iterative should be efficient for larger inputs', () => {
+            const start = performance.now();
+            const result = fibonacciIterative(20);
+            const end = performance.now();
+
+            expect(result).toBe(6765);
+            expect(end - start).toBeLessThan(1); // Should complete quickly
+        });
+
+        it('recursive should handle base cases', () => {
+            expect(fibonacciRecursive(0)).toBe(0);
+            expect(fibonacciRecursive(1)).toBe(1);
+            expect(fibonacciRecursive(2)).toBe(1);
+        });
+    });
+});

src/algorithm/recursion/recursion-fibonacci.ts

@@ -0,0 +1,45 @@
+// Given a number N return the index value of the Fibonacci sequence, where the sequence is:
+
+// 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144 ...
+// the pattern of the sequence is that each value is the sum of the 2 previous values, that means that for N=5 → 2+3
+
+//For example: fibonacciRecursive(6) should return 8
+
+
+export function fibonacciIterative(n: number) {
+    if (n < 0) return -1
+    if (n == 0) return 0
+    if (n == 1) return 1
+
+    let i = 2;
+    let first = 0;
+    let second = 1;
+    let sum = 1;
+    while (i <= n) {
+        sum = first + second // 1, 2, 3, 5, 8
+        first = second // 1, 1, 2, 3, 5
+        second = sum // 1, 2, 3, 5, 8
+        i++ // 3, 4, 5, 6, 7
+    }
+    return sum
+
+}
+
+console.log('fibonacciIterative(6)', fibonacciIterative(100));
+
+
+export function fibonacciRecursive(n: number): number {
+
+    // Điểm dừng
+    if (n < 0) return -1
+    if (n == 0) return 0
+    if (n <= 2) return 1
+    n--
+
+    return fibonacciRecursive(n) + fibonacciRecursive(n - 1)
+}
+// Ta có quy luật như sau: f(n) = f(n-1) + f(n-2). Ví dụ 8 = 5 + 3, 5 = 3 + 2
+// Nháp: 
+//f(6) => f(5) + f(4) = f(4) + f(3) + f(3) + f(2) = f(3) + f(2)
+
+// console.log("fibonacciRecursive", fibonacciRecursive(10));

src/algorithm/recursion/reverse-string.test.ts

@@ -0,0 +1,24 @@
+function reverseString(str: string) {
+    let result = ""
+    const length = str.length
+    for (let i = 0; i < length; i++) {
+        result += str[length - 1 - i]
+    }
+    return result
+}
+
+console.log(reverseString("yoyo master"));
+
+function reverseStringRecursive(str: string): string {
+
+    // return Điểm dừng
+    if (str.length == 0) return ""
+    // Return value (Recursive)
+
+    return str[str.length - 1] + reverseStringRecursive(str.slice(0, str.length - 1))
+}
+
+// console.log(reverseStringRecursive("yoyo master")) // output: "retsam oyoy"
+
+// Step 1: str = "yoyo master" -> return 'r' + reverseStringRecursive("yoyo maste") 
+// Step 2: str = "yoyo maste" -> return 'e' + reverseStringRecursive("yoyo mast")