Chunk Array - Practice Coding Problems

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

Understanding the Visualization

Input

Array [1,2,3,4,5] with chunk size 2

Process

Split into chunks of size 2

Output

Result [[1,2],[3,4],[5]]

Key Takeaway

🎯 Key Insight: Use array slicing to extract fixed-size chunks efficiently

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

Approach	Time	Space	Notes
✓ Optimized - Array Slicing	O(n)	O(n)	Use array slicing to extract chunks directly
Brute Force - Element by Element	O(n)	O(n)	Iterate through array and build chunks one element at a time

Optimized - Array Slicing — Algorithm Steps

Calculate number of chunks needed
For each chunk position, slice the array
Add sliced chunk directly to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Calculate positions for each chunk

Slice

Extract chunks directly using slicing

Result

Combine all chunks into final result

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;
    for (int i = 0; i < arrSize; i += size) {
        int chunkSize = (i + size > arrSize) ? (arrSize - i) : size;
        result[chunkIndex] = malloc(chunkSize * sizeof(int));
        (*returnColumnSizes)[chunkIndex] = chunkSize;
        
        for (int j = 0; j < chunkSize; j++) {
            result[chunkIndex][j] = arr[i + j];
        }
        chunkIndex++;
    }
    
    *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] >= '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 with slicing operations that copy n elements total

✓ 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

Optimized - Array Slicing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler