Circular Array Loop - Practice Coding Problems

Circular Array Loop - Problem

You are playing a game involving a circular array of non-zero integers nums. Imagine this as a circular board where you move according to the values at each position.

Movement Rules:

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, moving forward from the last element takes you to the first, and moving backward from the first takes you to the last

A valid cycle exists if you can find a sequence of indices where:

Following the movement rules creates a repeating sequence of indices
All values in the cycle have the same direction (all positive or all negative)
The cycle length is greater than 1

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

Example: [2, -1, 1, 2, 2] → At index 0: move 2 steps → index 2 → move 1 step → index 3 → move 2 steps → index 0 (cycle found!)

Input & Output

example_1.py — Valid Cycle Found

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

› Output: true

💡 Note: Starting at index 0: move 2 steps forward to index 2, then 1 step forward to index 3, then 2 steps forward to index 0. This creates a cycle 0→2→3→0 with all positive movements.

example_2.py — Direction Changes

$ Input: [-1, 2]

› Output: false

💡 Note: Starting at index 0: move 1 step backward to index 1, then move 2 steps forward to index 1. No valid cycle because directions are inconsistent (backward then forward).

example_3.py — Self Loop

$ Input: [1, -1, 5, 1, 4]

› Output: false

💡 Note: No valid cycles exist. Index 2 has value 5 which would create a self-loop (5 % 5 = 0), but cycles must have length > 1.

Visualization

Tap to expand

Understanding the Visualization

Choose starting position

Pick any position on the circular board

Follow movement rules

Move forward/backward based on the number at your current position

Track your path

Use two pointers moving at different speeds to detect when you loop back

Validate the cycle

Ensure all moves in the loop go the same direction and cycle length > 1

Key Takeaway

🎯 Key Insight: Use Floyd's cycle detection with direction validation to efficiently find valid cycles in O(n) time and O(1) space.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we start from each of n positions and may traverse up to n positions for each start

⚠ Quadratic Growth

Space Complexity

O(n)

Need to store visited indices for each path exploration

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 5000
-1000 ≤ nums[i] ≤ 1000
nums[i] ≠ 0
The array represents a circular structure

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses Floyd's Cycle Detection algorithm with direction validation. For each starting position, we use slow and fast pointers to detect cycles efficiently in O(n) time and O(1) space. The key insight is to validate direction consistency during traversal and mark visited elements to avoid redundant work.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try Every Starting Position)	O(n²)	O(n)	Check every possible starting position and follow the path until finding a cycle or determining no cycle exists
Floyd's Cycle Detection (Two Pointers)	O(n)	O(1)	Use fast and slow pointers to detect cycles efficiently while validating direction consistency

Brute Force (Try Every Starting Position) — Algorithm Steps

For each starting index i in the array
Follow the movement rules from index i, keeping track of the path
Use a visited set to detect when we revisit an index
When a cycle is detected, validate it meets all requirements
Return true if any valid cycle is found, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from index 0

Begin exploration from first position

Follow movement rules

Move according to the value at current position

Track visited positions

Mark each position we visit to detect cycles

Validate cycle

Check if cycle meets all requirements when found

Code -

solution.c — C

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

int getNext(int i, int* nums, int n) {
    int result = (i + nums[i]) % n;
    return result >= 0 ? result : result + n;
}

bool circularArrayLoop(int* nums, int numsSize) {
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == 0) continue;
        
        bool* visited = (bool*)calloc(numsSize, sizeof(bool));
        int current = i;
        
        while (!visited[current]) {
            visited[current] = true;
            int nextIdx = getNext(current, nums, numsSize);
            
            // Check if direction changes
            if (nums[current] * nums[nextIdx] < 0) {
                break;
            }
            
            // Check for self-loop
            if (nextIdx == current) {
                break;
            }
            
            current = nextIdx;
        }
        
        bool foundCycle = visited[current];
        free(visited);
        
        if (foundCycle) {
            return true;
        }
    }
    
    return false;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we start from each of n positions and may traverse up to n positions for each start

⚠ Quadratic Growth

Space Complexity

O(n)

Need to store visited indices for each path exploration

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 5000
-1000 ≤ nums[i] ≤ 1000
nums[i] ≠ 0
The array represents a circular structure

42.0K Views

Medium Frequency

~25 min Avg. Time

1.9K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try Every Starting Position) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler