Chunk Array

Chunk Array - Problem

JavaScript Easy

Given an array arr and a chunk size size, return a chunked array.

A chunked array contains the original elements in arr, but consists of subarrays each of length size. The length of the last subarray may be less than size if arr.length is not evenly divisible by size.

You may not use lodash's _.chunk function.

Input & Output

Example 1 — Basic Chunking

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

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

💡 Note: Split array into chunks of size 2: first chunk [1,2], second chunk [3,4], last chunk [5] has only 1 element

Example 2 — Perfect Division

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

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

💡 Note: Array length 6 divides evenly by size 3, creating two complete chunks of 3 elements each

Example 3 — 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

Constraints

1 ≤ arr.length ≤ 1000
1 ≤ size ≤ arr.length
-1000 ≤ arr[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 M Microsoft 15

The key insight is to split an array into fixed-size subarrays. Best approach uses array slicing to extract chunks directly in one pass. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Element by Element

⏱️ Time: O(n) Space: O(n)

Go through each element in the array and add it to the current chunk. When the chunk reaches the desired size, start a new chunk. This approach builds the result incrementally.

Optimized - Array Slicing

⏱️ Time: O(n) Space: O(n)

Instead of building chunks element by element, use array slicing to extract complete chunks in each iteration. This approach is more efficient and cleaner.

Brute Force - Element by Element — Algorithm Steps

Initialize empty result array and current chunk
For each element, add to current chunk
When chunk size is reached, add chunk to result and start new chunk
Add any remaining elements as final chunk

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty result and current chunk

Add Elements

Add elements to current chunk until size is reached

Complete Chunks

Move full chunks to result and start new chunk

Code -

solution.c — C

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

int** solution(int* arr, int arrSize, int size, int* returnSize, int** returnColumnSizes) {
    int numChunks = (arrSize + size - 1) / size;
    int** result = malloc(numChunks * sizeof(int*));
    *returnColumnSizes = malloc(numChunks * sizeof(int));
    
    int chunkIndex = 0;
    int currentChunkSize = 0;
    
    for (int i = 0; i < arrSize; i++) {
        if (currentChunkSize == 0) {
            int remainingElements = arrSize - i;
            int thisChunkSize = (remainingElements < size) ? remainingElements : size;
            result[chunkIndex] = malloc(thisChunkSize * sizeof(int));
            (*returnColumnSizes)[chunkIndex] = thisChunkSize;
        }
        
        result[chunkIndex][currentChunkSize] = arr[i];
        currentChunkSize++;
        
        if (currentChunkSize == size || i == arrSize - 1) {
            chunkIndex++;
            currentChunkSize = 0;
        }
    }
    
    *returnSize = numChunks;
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int arr[1000];
    int arrSize = 0;
    
    char* token = strtok(line, "[,]\n");
    while (token != NULL) {
        if (strlen(token) > 0 && (token[0] == '-' || (token[0] >= '0' && token[0] <= '9'))) {
            arr[arrSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]\n");
    }
    
    int size;
    scanf("%d", &size);
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(arr, arrSize, size, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop through all n elements

✓ Linear Growth

Space Complexity

O(n)

Result array stores all n elements in chunks

⚡ Linearithmic Space

28.0K 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 - Element by Element — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler