Minimum Size Subarray in Infinite Array - Practice Coding Problems

Minimum Size Subarray in Infinite Array - Problem

You are given a 0-indexed array nums and an integer target.

Imagine creating an infinite array by repeatedly appending the elements of nums to itself: [nums[0], nums[1], ..., nums[n-1], nums[0], nums[1], ..., nums[n-1], ...]

Your task is to find the shortest contiguous subarray within this infinite array that has a sum exactly equal to target.

Return: The length of the shortest such subarray, or -1 if no such subarray exists.

Example: If nums = [1, 2, 3] and target = 5, the infinite array looks like [1, 2, 3, 1, 2, 3, 1, 2, 3, ...]. The shortest subarray with sum 5 is [2, 3] with length 2.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,2,3], target = 5

› Output: 2

💡 Note: The infinite array is [1,2,3,1,2,3,1,2,3,...]. The shortest subarray with sum 5 is [2,3] with length 2.

example_2.py — Multiple Cycles

$ Input: nums = [1,1,1,2,3], target = 4

› Output: 2

💡 Note: The infinite array is [1,1,1,2,3,1,1,1,2,3,...]. The shortest subarray with sum 4 is [1,3] with length 2.

example_3.py — No Solution

$ Input: nums = [2,4,6,8], target = 3

› Output: -1

💡 Note: Since all numbers in nums are even and 3 is odd, no subarray can sum to 3.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
1 ≤ target ≤ 10⁹
All elements in nums are positive integers

Visualization

Tap to expand

Understanding the Visualization

Map the Circular Path

The array [1,2,3] becomes an infinite circular path: 1→2→3→1→2→3...

Calculate Full Laps

If target is much larger than array sum, calculate how many complete laps needed

Find Shortest Segment

For remaining target, find shortest path segment using prefix sums

Combine Results

Total distance = (Full laps × path length) + shortest segment

Key Takeaway

🎯 Key Insight: By recognizing that we only need to check at most 2 complete cycles and using prefix sums, we can solve this efficiently in O(n) time instead of brute force O(n × target).

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses prefix sums with hash map in O(n) time. Key insight: we only need to consider at most 2 complete cycles of the array. First calculate how many full cycles are needed, then find the shortest subarray for the remaining target using prefix sum differences.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Sum with Hash Map (Optimal)	O(n)	O(n)	Use prefix sums and hash map to efficiently find subarray with target sum
Brute Force (Try All Subarrays)	O(n * target)	O(1)	Try every possible starting position and expand until we find the target sum

Prefix Sum with Hash Map (Optimal) — Algorithm Steps

Calculate the total sum of the original array
Determine how many full cycles we need: target // total_sum
Find the remaining target after full cycles: target % total_sum
Use sliding window technique on extended array (2 cycles) to find shortest subarray
Combine full cycles length with shortest subarray length

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Total Sum

Find sum of original array and determine full cycles needed

Find Remaining Target

Calculate what sum we need after full cycles

Build Prefix Sum Map

Track prefix sums and their positions in hash map

Find Shortest Subarray

Use prefix sum difference to find target subarray

Code -

solution.c — C

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

// Simple hash table implementation for this problem
#define HASH_SIZE 10007

typedef struct Node {
    long long key;
    int value;
    struct Node* next;
} Node;

typedef struct {
    Node* buckets[HASH_SIZE];
} HashMap;

int hash(long long key) {
    return (key % HASH_SIZE + HASH_SIZE) % HASH_SIZE;
}

void put(HashMap* map, long long key, int value) {
    int idx = hash(key);
    Node* node = map->buckets[idx];
    while (node) {
        if (node->key == key) {
            node->value = value;
            return;
        }
        node = node->next;
    }
    Node* newNode = malloc(sizeof(Node));
    newNode->key = key;
    newNode->value = value;
    newNode->next = map->buckets[idx];
    map->buckets[idx] = newNode;
}

int get(HashMap* map, long long key, int* found) {
    int idx = hash(key);
    Node* node = map->buckets[idx];
    while (node) {
        if (node->key == key) {
            *found = 1;
            return node->value;
        }
        node = node->next;
    }
    *found = 0;
    return -1;
}

int minSizeSubarray(int* nums, int numsSize, int target) {
    long long totalSum = 0;
    for (int i = 0; i < numsSize; i++) {
        totalSum += nums[i];
    }
    
    if (totalSum == 0) {
        if (target == 0) {
            for (int i = 0; i < numsSize; i++) {
                if (nums[i] == 0) return 1;
            }
        }
        return -1;
    }
    
    long long fullCycles = totalSum > 0 ? target / totalSum : 0;
    long long remainingTarget = target - fullCycles * totalSum;
    
    if (remainingTarget == 0) {
        return fullCycles * numsSize;
    }
    
    HashMap map = {0};
    put(&map, 0, -1);
    
    long long prefixSum = 0;
    int minLength = INT_MAX;
    
    for (int i = 0; i < 2 * numsSize; i++) {
        prefixSum += nums[i % numsSize];
        long long targetSum = prefixSum - remainingTarget;
        
        int found;
        int idx = get(&map, targetSum, &found);
        if (found) {
            int length = i - idx;
            if (length <= numsSize && length < minLength) {
                minLength = length;
            }
        }
        
        put(&map, prefixSum, i);
    }
    
    return minLength == INT_MAX ? -1 : fullCycles * numsSize + minLength;
}

int main() {
    // Input parsing would go here
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We process each element at most twice (in 2 cycles of the array)

✓ Linear Growth

Space Complexity

O(n)

Hash map to store prefix sum positions, at most 2n entries

⚡ Linearithmic Space

31.8K Views

Medium Frequency

~25 min Avg. Time

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

Prefix Sum with Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler