Generate Circular Array Values - Practice Coding Problems

Generate Circular Array Values - Problem

JavaScript Medium

Imagine you're building a circular playlist navigator that can jump around tracks in a loop! 🎵

Given a circular array arr and an integer startIndex, you need to create a generator object that yields values from the array. Think of it as a smart pointer that can jump around a circular track.

How it works:

First call to gen.next() yields arr[startIndex]
Subsequent calls pass a jump parameter: gen.next(jump)
Positive jump: Move forward, wrapping to start if at end
Negative jump: Move backward, wrapping to end if at start

The array behaves like a circular track where the last element connects back to the first!

Input & Output

example_1.js — Basic Forward Jump

$ Input: arr = [1, 2, 3, 4, 5], startIndex = 2 gen.next() // First call gen.next(3) // Jump forward by 3

› Output: 3 (initial) 1 (after jump)

💡 Note: Start at index 2 (value 3). Jump forward by 3: (2+3)%5 = 0, so we land at index 0 (value 1)

example_2.js — Negative Jump with Wrap

$ Input: arr = [1, 2, 3, 4, 5], startIndex = 1 gen.next() // First call gen.next(-2) // Jump backward by 2

› Output: 2 (initial) 5 (after jump)

💡 Note: Start at index 1 (value 2). Jump backward by 2: (1-2)%5 = -1, which becomes index 4 (value 5) after handling negative result

example_3.js — Large Jump

$ Input: arr = [10, 20, 30], startIndex = 0 gen.next() // First call gen.next(7) // Large forward jump

› Output: 10 (initial) 20 (after jump)

💡 Note: Start at index 0 (value 10). Jump forward by 7: (0+7)%3 = 1, so we land at index 1 (value 20). Large jumps wrap around multiple times.

Constraints

1 ≤ arr.length ≤ 10⁴
0 ≤ startIndex < arr.length
-10⁹ ≤ jump ≤ 10⁹
Array elements can be any integer values
Generator should handle unlimited jumps

Visualization

Tap to expand

Understanding the Visualization

Initialize Generator

Set starting position and prepare to yield values

Calculate Jump

Use modular arithmetic: (current + jump) % length

Handle Negatives

Add array length if result is negative

Yield Value

Return value at calculated position

Key Takeaway

🎯 Key Insight: Modular arithmetic transforms a potentially O(n) step-counting problem into an elegant O(1) direct calculation, making the generator efficient even for massive jumps.

Asked in

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

The optimal solution uses modular arithmetic to calculate new positions directly in O(1) time per jump. Instead of iterating step-by-step, we compute (currentIndex + jump) % arrayLength and handle negative results by adding the array length. This generator pattern maintains state between calls while providing efficient circular navigation.

Common Approaches

Approach	Time	Space	Notes
✓ Modular Arithmetic (Optimal)	O(1)	O(1)	Use modular arithmetic to calculate new position directly in O(1)
Brute Force (Step-by-Step Movement)	O(k)	O(1)	Move index one step at a time until reaching the target position

Modular Arithmetic (Optimal) — Algorithm Steps

Store current index and array reference
For any jump, calculate: newIndex = (currentIndex + jump) % arrayLength
Handle negative results by adding arrayLength
Return value at calculated index

Visualization

Tap to expand

Step-by-Step Walkthrough

Current Position

Start at index 2 with value 3

Apply Formula

(2 + 3) % 5 = 0, jump to index 0

Instant Result

No iteration needed - direct calculation

Code -

solution.c — C

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

typedef struct {
    int* arr;
    int size;
    int currentIndex;
} CircularGenerator;

CircularGenerator* createGenerator(int* arr, int size, int startIndex) {
    CircularGenerator* gen = malloc(sizeof(CircularGenerator));
    gen->arr = arr;
    gen->size = size;
    gen->currentIndex = startIndex;
    return gen;
}

int nextWithJump(CircularGenerator* gen, int jump) {
    // Calculate new index using modular arithmetic
    gen->currentIndex = (gen->currentIndex + jump) % gen->size;
    
    // Handle negative results
    if (gen->currentIndex < 0) {
        gen->currentIndex += gen->size;
    }
    
    return gen->arr[gen->currentIndex];
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each jump operation is calculated directly using modular arithmetic

✓ Linear Growth

Space Complexity

O(1)

Only storing current index and array reference

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

945 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

Modular Arithmetic (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler