Generate Fibonacci Sequence - Practice Coding Problems

Generate Fibonacci Sequence - Problem

JavaScript Easy

Generate Fibonacci Sequence using JavaScript Generators

Create a generator function that yields the famous Fibonacci sequence infinitely. The Fibonacci sequence is one of the most beautiful patterns in mathematics, where each number is the sum of the two preceding numbers.

The sequence follows the rule: F(n) = F(n-1) + F(n-2)

Starting with 0, 1, the sequence produces: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55...

Goal: Implement a generator function that can be called to create an iterator object. Each call to next() should return the next Fibonacci number in the sequence.

Key Requirements:
• Use JavaScript's function* syntax (generator function)
• Use the yield keyword to produce values
• Generate values on-demand (lazy evaluation)
• Handle infinite sequence generation efficiently

Input & Output

example_1.js — Basic Usage

$ Input: const gen = fibonacciGenerator(); for (let i = 0; i < 8; i++) { console.log(gen.next().value); }

› Output: 0 1 1 2 3 5 8 13

💡 Note: The generator starts with 0 and 1, then each subsequent number is the sum of the previous two numbers. This demonstrates the basic usage of the Fibonacci generator.

example_2.js — Array Collection

$ Input: const gen = fibonacciGenerator(); const first10 = []; for (let i = 0; i < 10; i++) { first10.push(gen.next().value); } console.log(first10);

› Output: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

💡 Note: This example shows how to collect multiple Fibonacci numbers into an array. The generator maintains its state between calls, producing the sequence correctly.

example_3.js — Large Numbers

$ Input: const gen = fibonacciGenerator(); // Skip to 15th number for (let i = 0; i < 15; i++) gen.next(); // Get next 3 numbers console.log(gen.next().value); console.log(gen.next().value); console.log(gen.next().value);

› Output: 610 987 1597

💡 Note: Demonstrates that the generator can handle larger Fibonacci numbers and maintains state correctly even when we skip ahead in the sequence.

Constraints

The generator should use function* syntax
Must use the yield keyword to produce values
Should generate numbers on-demand (lazy evaluation)
Numbers may exceed JavaScript's safe integer range for very large sequences
Memory usage should be O(1) regardless of sequence length

Visualization

Tap to expand

Understanding the Visualization

Initialization

Start with current=0 and next=1, representing the first two Fibonacci numbers

Yield Current

Return the current value to the caller

Update State

Slide the window: current becomes next, next becomes current + next

Repeat

Continue the pattern infinitely, generating numbers on-demand

Key Takeaway

🎯 Key Insight: Generators with two-variable sliding window provide infinite Fibonacci sequences with optimal O(1) space and time complexity per number.

Asked in

G Google 25 a Amazon 18 f Meta 22 ⊞ Microsoft 15

The optimal solution uses a generator function with two variables to track the sequence state. This provides O(1) time per number and O(1) space complexity while supporting infinite sequence generation through lazy evaluation.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal Generator (Iterative)	O(1)	O(1)	Efficient generator using two variables to track the sequence state
Brute Force (Recursive)	O(2^n)	O(n)	Recursive generator that recalculates each Fibonacci number from scratch

Optimal Generator (Iterative) — Algorithm Steps

Initialize two variables: current (0) and next (1)
Yield the current value
Update both variables: new_current = next, new_next = current + next
Repeat infinitely using the generator pattern

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

current = 0, next = 1

Yield & Update

Yield current (0), then slide: current = 1, next = 1

Continue Pattern

Yield current (1), then slide: current = 1, next = 2

Infinite Loop

Pattern continues infinitely with O(1) space

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    long long current;
    long long next;
} FibGenerator;

FibGenerator* createFibGenerator() {
    FibGenerator* gen = malloc(sizeof(FibGenerator));
    gen->current = 0;
    gen->next = 1;
    return gen;
}

long long nextFib(FibGenerator* gen) {
    long long result = gen->current;
    long long temp = gen->current + gen->next;
    gen->current = gen->next;
    gen->next = temp;
    return result;
}

int main() {
    FibGenerator* gen = createFibGenerator();
    printf("First 15 Fibonacci numbers: ");
    for (int i = 0; i < 15; i++) {
        printf("%lld%s", nextFib(gen), i < 14 ? ", " : "\n");
    }
    free(gen);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each number is generated in constant time using the previous two values

✓ Linear Growth

Space Complexity

O(1)

Only stores two variables regardless of sequence length

✓ Linear Space

23.4K Views

Medium Frequency

~12 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Optimal Generator (Iterative) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler