Divide a String Into Groups of Size k - Practice Coding Problems

Divide a String Into Groups of Size k - Problem

String Simulation Easy

Imagine you're a librarian organizing books into boxes of equal size! Given a string s, you need to divide it into groups of exactly k characters.

Here's how the process works:

📦 The first group gets the first k characters
📦 The second group gets the next k characters
📦 And so on...

But what if the last group doesn't have enough characters? No problem! We use a special fill character to pad it to size k.

Goal: Return an array of strings where each string represents one group of size k.

Example: If s = "abcdefg", k = 3, and fill = 'x', we get ["abc", "def", "gxx"]

Input & Output

example_1.py — Basic Division

$ Input: s = "abcdefghi", k = 3, fill = "x"

› Output: ["abc", "def", "ghi"]

💡 Note: The string has exactly 9 characters, which divides perfectly into 3 groups of size 3. No fill character is needed since each group has exactly k characters.

example_2.py — Padding Required

$ Input: s = "abcdefg", k = 3, fill = "x"

› Output: ["abc", "def", "gxx"]

💡 Note: The string has 7 characters. The first two groups get 3 characters each: "abc" and "def". The last group only has 1 character "g", so we pad it with 2 'x' characters to make "gxx".

example_3.py — Single Character

$ Input: s = "a", k = 5, fill = "*"

› Output: ["a****"]

💡 Note: Edge case: The string has only 1 character but k=5. We need to create one group with the single character 'a' followed by 4 fill characters '*' to reach the required size of 5.

Visualization

Tap to expand

Understanding the Visualization

Survey the Shelf

Look at your string of characters - these are your 'books' to organize

Prepare Boxes

Each box (group) must hold exactly k books (characters)

Fill Boxes in Order

Take books from left to right, filling each box completely

Add Dummy Books

If the last box isn't full, add dummy books (fill character) to complete it

Key Takeaway

🎯 Key Insight: This problem is essentially about string partitioning with padding. The optimal solution processes the string in chunks of size k, making it both efficient and intuitive to understand.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each character exactly once, and string slicing is O(k) for each group

✓ Linear Growth

Space Complexity

O(n)

We store the result array, which contains all characters from the input plus any fill characters

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 100
s consists of lowercase English letters only
1 ≤ k ≤ 100
fill is a lowercase English letter
The last group will be padded with fill character if needed

Asked in

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

This problem is best solved using string slicing in a single pass. The optimal approach iterates through the string in steps of k, extracting groups using efficient substring operations. The key insight is that we only need to handle padding for the final group, making the solution both simple and efficient with O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Character by Character)	O(n * k)	O(n)	Build each group one character at a time with nested operations
One-Pass String Slicing (Optimal)	O(n)	O(n)	Use string slicing to extract groups in a single pass through the string

Brute Force (Character by Character) — Algorithm Steps

Calculate how many complete groups we need: (length + k - 1) / k
For each group position, create an empty group string
For each character position in the group, add either the original character or fill character
Add the completed group to our result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Groups

Determine how many groups of size k we need

Build Each Group

For each group, examine k character positions

Fill or Use Original

Use original character if available, otherwise use fill character

Complete Group

Add completed group to result array

Code -

solution.c — C

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

char** divideString(char* s, int k, char fill, int* returnSize) {
    int n = strlen(s);
    int numGroups = (n + k - 1) / k;
    
    char** result = (char**)malloc(numGroups * sizeof(char*));
    *returnSize = numGroups;
    
    for (int groupIdx = 0; groupIdx < numGroups; groupIdx++) {
        result[groupIdx] = (char*)malloc((k + 1) * sizeof(char));
        // Build each group character by character
        for (int pos = 0; pos < k; pos++) {
            int charIdx = groupIdx * k + pos;
            if (charIdx < n) {
                result[groupIdx][pos] = s[charIdx];
            } else {
                result[groupIdx][pos] = fill;
            }
        }
        result[groupIdx][k] = '\0';
    }
    
    return result;
}

int main() {
    char s[1000], fillStr[10];
    int k;
    scanf("%s %d %s", s, &k, fillStr);
    // Remove quotes
    memmove(s, s+1, strlen(s));
    s[strlen(s)-1] = '\0';
    char fill = fillStr[1];
    
    int returnSize;
    char** result = divideString(s, k, fill, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(", ");
        free(result[i]);
    }
    printf("]\n");
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * k)

We process n characters, and for each group we might do k operations to build the string

✓ Linear Growth

Space Complexity

O(n)

We store the result array plus intermediate group strings

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 100
s consists of lowercase English letters only
1 ≤ k ≤ 100
fill is a lowercase English letter
The last group will be padded with fill character if needed

23.5K Views

Medium Frequency

~12 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

Brute Force (Character by Character) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler