Circular Array Loop

Circular Array Loop - Problem

You are playing a game involving a circular array of non-zero integers nums. Each nums[i] denotes the number of indices forward/backward you must move if you are located at index i:

If nums[i] is positive, move nums[i] steps forward
If nums[i] is negative, move abs(nums[i]) steps backward

Since the array is circular, you may assume that moving forward from the last element puts you on the first element, and moving backwards from the first element puts you on the last element.

A cycle in the array consists of a sequence of indices seq of length k where:

Following the movement rules above results in the repeating index sequence seq[0] -> seq[1] -> ... -> seq[k-1] -> seq[0] -> ...
Every nums[seq[j]] is either all positive or all negative
k > 1 (cycle must have more than one element)

Return true if there is a cycle in nums, or false otherwise.

Input & Output

Example 1 — Valid Cycle

$ Input: nums = [2,-1,1,-2]

› Output: false

💡 Note: Starting from any index, we cannot form a valid cycle. From index 1: 1→0→2→3→1, but this cycle has mixed directions (nums[0]=2 positive, nums[1]=-1 negative), violating the same-direction rule.

Example 2 — No Valid Cycle

$ Input: nums = [-1,2]

› Output: false

💡 Note: Index 0 moves to index 1, index 1 moves to index 1 (self-loop). Self-loops are invalid since cycle length must be > 1.

Example 3 — Direction Change

$ Input: nums = [-2,1,-1,-2,-2]

› Output: false

💡 Note: No valid cycle exists because paths either lead to direction changes or form invalid cycles.

Constraints

1 ≤ nums.length ≤ 5000
-1000 ≤ nums[i] ≤ 1000
nums[i] ≠ 0

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 A Apple 15

The key insight is to detect cycles in a circular array while ensuring direction consistency and cycle length > 1. Best approach uses Floyd's cycle detection with path marking optimization. Time: O(n), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Check Every Starting Point	O(n²)	O(n)	Start from each index and follow the path until we find a cycle or determine no cycle exists
Floyd's Cycle Detection (Fast & Slow Pointers)	O(n²)	O(1)	Use fast and slow pointers to detect cycles efficiently, similar to detecting cycles in linked lists
Optimized with Path Marking	O(n)	O(n)	Mark visited nodes to avoid redundant checks and detect cycles efficiently

Brute Force - Check Every Starting Point — Algorithm Steps

Step 1: For each starting index, begin path traversal
Step 2: Follow movement rules and track visited indices
Step 3: Check if revisited index forms valid cycle
Step 4: Validate cycle direction consistency and length > 1

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Index 0

Begin traversal from first index

Follow Path

Move according to array values, track visited

Detect Cycle

Check if we revisit an index with valid conditions

Code -

solution.c — C

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

int nextIndex(int* nums, int numsSize, int i) {
    return (i + nums[i] % numsSize + numsSize) % numsSize;
}

bool hasCycleFrom(int* nums, int numsSize, int start) {
    bool* visited = (bool*)calloc(numsSize, sizeof(bool));
    int curr = start;
    
    while (!visited[curr]) {
        if (nums[curr] == 0) {
            free(visited);
            return false;
        }
        visited[curr] = true;
        int nextCurr = nextIndex(nums, numsSize, curr);
        
        // Check if direction changes
        if ((nums[curr] > 0) != (nums[nextCurr] > 0)) {
            free(visited);
            return false;
        }
        
        curr = nextCurr;
    }
    
    // Found a cycle, check if it's valid (length > 1)
    int cycleStart = curr;
    int cycleLength = 1;
    curr = nextIndex(nums, numsSize, curr);
    
    while (curr != cycleStart) {
        cycleLength++;
        curr = nextIndex(nums, numsSize, curr);
    }
    
    free(visited);
    return cycleLength > 1;
}

bool solution(int* nums, int numsSize) {
    for (int i = 0; i < numsSize; i++) {
        if (hasCycleFrom(nums, numsSize, i)) {
            return true;
        }
    }
    
    return false;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[1000];
    int numsSize = 0;
    
    char* ptr = strchr(line, '[');
    ptr++;
    
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    bool result = solution(nums, numsSize);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n starting points, we may traverse up to n indices

⚠ Quadratic Growth

Space Complexity

O(n)

Hash set to track visited indices for each starting point

⚡ Linearithmic Space

34.5K Views

Medium Frequency

~25 min Avg. Time

890 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 - Check Every Starting Point — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler