Chunk Array - Practice Coding Problems

Chunk Array - Problem

JavaScript Easy

Given an array arr and a positive integer size, your task is to divide the array into smaller subarrays (chunks) where each chunk contains exactly size elements.

Think of it like organizing items into boxes: if you have 10 items and want to put 3 items per box, you'd get 3 boxes with 3 items each, and 1 box with the remaining 1 item.

Key Points:

Each chunk should have exactly size elements
The last chunk may have fewer elements if the array length isn't evenly divisible by size
Maintain the original order of elements
Return an array of subarrays (chunks)

Example: [1, 2, 3, 4, 5] with size 2 becomes [[1, 2], [3, 4], [5]]

Input & Output

example_1.py — Basic chunking

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

› Output: [[1, 2], [3, 4], [5]]

💡 Note: The array is divided into chunks of size 2. First chunk gets [1,2], second chunk gets [3,4], and the last chunk gets the remaining element [5].

example_2.py — Perfect division

$ Input: arr = [1, 2, 3, 4, 5, 6], size = 3

› Output: [[1, 2, 3], [4, 5, 6]]

💡 Note: The array length (6) is perfectly divisible by chunk size (3), resulting in two complete chunks of equal size.

example_3.py — Single element chunks

$ Input: arr = [1, 2, 3], size = 1

› Output: [[1], [2], [3]]

💡 Note: Each element becomes its own chunk when size is 1. This creates individual arrays for each element.

Visualization

Tap to expand

Understanding the Visualization

Setup

Start with an empty box and conveyor belt of items

Fill Box

Take items from belt and place them in current box until full

New Box

When box is full, seal it and start packing a new box

Final Box

When items run out, seal the partially filled box

Key Takeaway

🎯 Key Insight: Sequential processing mirrors real-world packing - we don't need to pre-calculate positions, just fill boxes naturally as items arrive!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element is processed exactly once

✓ Linear Growth

Space Complexity

O(n)

Space needed for the result array containing all elements

⚡ Linearithmic Space

Constraints

1 ≤ size ≤ 1000
0 ≤ arr.length ≤ 1000
-1000 ≤ arr[i] ≤ 1000
Do not use lodash's _.chunk function

Asked in

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

The sequential chunking approach is optimal for this problem. Simply iterate through the array, adding elements to the current chunk until it reaches the desired size, then start a new chunk. This natural approach requires only O(n) time and O(n) space, making it both intuitive and efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Sequential Chunking (Optimal)	O(n)	O(n)	Build chunks sequentially by adding elements to current chunk until full
Brute Force (Index Calculation)	O(n)	O(n)	Calculate which chunk each element belongs to using division and modulo operations

Sequential Chunking (Optimal) — Algorithm Steps

Initialize empty result array and current chunk
Iterate through each element in the input array
Add current element to the current chunk
If current chunk reaches desired size, add it to result and start new chunk
After loop ends, add any remaining elements in the last chunk

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Processing

Begin with empty current chunk

Fill Current Chunk

Add elements until chunk is full

Move to Next Chunk

Start new chunk when current is full

Handle Remainder

Add final partial chunk if needed

Code -

solution.c — C

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

int** chunk(int* arr, int arrSize, int size, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    if (!arr || arrSize == 0 || size <= 0) {
        return NULL;
    }
    
    // Calculate maximum possible chunks
    int maxChunks = (arrSize + size - 1) / size;
    int** result = (int**)malloc(maxChunks * sizeof(int*));
    *returnColumnSizes = (int*)malloc(maxChunks * sizeof(int));
    
    int chunkIndex = 0;
    int elementIndex = 0;
    
    while (elementIndex < arrSize) {
        // Determine size of current chunk
        int currentChunkSize = (elementIndex + size <= arrSize) ? size : (arrSize - elementIndex);
        
        // Allocate memory for current chunk
        result[chunkIndex] = (int*)malloc(currentChunkSize * sizeof(int));
        (*returnColumnSizes)[chunkIndex] = currentChunkSize;
        
        // Fill current chunk
        for (int i = 0; i < currentChunkSize; i++) {
            result[chunkIndex][i] = arr[elementIndex++];
        }
        
        chunkIndex++;
    }
    
    *returnSize = chunkIndex;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element is processed exactly once

✓ Linear Growth

Space Complexity

O(n)

Space needed for the result array containing all elements

⚡ Linearithmic Space

Constraints

1 ≤ size ≤ 1000
0 ≤ arr.length ≤ 1000
-1000 ≤ arr[i] ≤ 1000
Do not use lodash's _.chunk function

25.6K Views

Medium Frequency

~15 min Avg. Time

892 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

Sequential Chunking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler