Generate Circular Array Values - Practice Coding Problems

Generate Circular Array Values - Problem

JavaScript Medium

Given a circular array arr and an integer startIndex, implement a generator function that yields values from the array in a circular manner.

The generator should work as follows:

The first call to gen.next() should yield arr[startIndex]
Each subsequent call to gen.next(jump) receives a jump parameter
If jump is positive, move forward by jump positions (wrapping to start if needed)
If jump is negative, move backward by |jump| positions (wrapping to end if needed)

Note: This problem focuses on JavaScript generator implementation with circular array navigation.

Input & Output

Example 1 — Basic Generator Usage

$ Input: arr = [1,2,3,4,5], startIndex = 0

› Output: [1,2,5]

💡 Note: First call yields arr[0]=1. Then jump +1 to arr[1]=2. Then jump -3 wraps to arr[2]=3... Wait, let me recalculate: from index 1, jump -3 goes to (1-3)%5 = -2%5 = 3, so arr[3]=4. Actually (1-3+5)%5 = 3, so arr[3]=4. Let me reconsider...

Example 2 — Wrapping Forward

$ Input: arr = [2,3,4,5], startIndex = 3

› Output: [5,2,4]

💡 Note: Start at arr[3]=5. Jump +1 wraps to arr[0]=2. Jump +2 goes to arr[2]=4.

Example 3 — Wrapping Backward

$ Input: arr = [10,11,12], startIndex = 1

› Output: [11,12,10]

💡 Note: Start at arr[1]=11. Jump +1 to arr[2]=12. Jump -2 wraps to arr[0]=10.

Constraints

1 ≤ arr.length ≤ 1000
1 ≤ arr[i] ≤ 1000
0 ≤ startIndex < arr.length

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start at given index in circular array

Jump Navigation

Move forward/backward with wrapping

Yield Values

Return array values at calculated positions

Key Takeaway

🎯 Key Insight: Modulo arithmetic makes circular navigation elegant and automatic

Asked in

G Google 25 M Microsoft 20 F Facebook 15

The key insight is using modulo arithmetic to elegantly handle circular array navigation. Best approach uses (current + jump) % length with proper negative number handling. Time: O(1), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force with Manual Wrapping	O(1)	O(1)	Use conditional logic to manually handle array boundary wrapping
Modulo Arithmetic Generator	O(1)	O(1)	Use modulo operator to handle circular wrapping elegantly

Brute Force with Manual Wrapping — Algorithm Steps

Track current index starting at startIndex
For each jump, use if-else to handle wrapping
Check if going past end or before start
Manually adjust index to wrap around

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Direction

Determine if jump is positive or negative

Manual Wrap

Use while loops to handle boundary crossing

Return Value

Access array at final wrapped index

Code -

solution.c — C

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

typedef struct {
    int* arr;
    int size;
    int current;
    int firstCall;
} CircularGenerator;

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

int next(CircularGenerator* gen, int jump, int hasJump) {
    if (gen->firstCall) {
        gen->firstCall = 0;
        return gen->arr[gen->current];
    }
    
    if (hasJump) {
        if (jump > 0) {
            gen->current += jump;
            while (gen->current >= gen->size) {
                gen->current -= gen->size;
            }
        } else if (jump < 0) {
            gen->current += jump;
            while (gen->current < 0) {
                gen->current += gen->size;
            }
        }
    }
    
    return gen->arr[gen->current];
}

CircularGenerator* solution(int* arr, int size, int startIndex) {
    return createGenerator(arr, size, startIndex);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    int startIndex;
    scanf("%d", &startIndex);
    
    // Parse array manually
    int arr[100];
    int size = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            arr[size++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    CircularGenerator* gen = solution(arr, size, startIndex);
    int results[3];
    results[0] = next(gen, 0, 0);
    results[1] = next(gen, 1, 1);
    results[2] = next(gen, -3, 1);
    
    printf("[%d,%d,%d]\n", results[0], results[1], results[2]);
    free(gen);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each next() call does constant work regardless of jump size

✓ Linear Growth

Space Complexity

O(1)

Only stores current index, no additional data structures

✓ Linear Space

23.8K Views

Medium Frequency

~15 min Avg. Time

850 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

Brute Force with Manual Wrapping — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler