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

Divide a String Into Groups of Size k - Problem

String Simulation Easy

A string s can be partitioned into groups of size k using the following procedure:

The first group consists of the first k characters of the string, the second group consists of the next k characters of the string, and so on. Each character can be a part of exactly one group.
For the last group, if the string does not have k characters remaining, a character fill is used to complete the group.

Note that the partition is done so that after removing the fill character from the last group (if it exists) and concatenating all the groups in order, the resultant string should be s.

Given the string s, the size of each group k and the character fill, return a string array denoting the composition of every group s has been divided into, using the above procedure.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: The string has exactly 9 characters, which divides evenly into 3 groups of size 3: "abc", "def", "ghi". No padding needed.

Example 2 — Padding Required

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

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

💡 Note: The string has 7 characters. First two groups are complete: "abc", "def". Last group "g" needs padding with "x" to become "gxx".

Example 3 — Single Character Group

$ Input: s = "a", k = 3, fill = "b"

› Output: ["abb"]

💡 Note: Single character "a" forms one group, padded with "b" twice to reach size 3: "abb".

Constraints

1 ≤ s.length ≤ 100
s consists of lowercase English letters only
1 ≤ k ≤ 100
fill is a lowercase English letter

Visualization

Tap to expand

Understanding the Visualization

Input

Original string s, group size k, and fill character

Group Formation

Divide string into groups of size k

Padding

Add fill characters to incomplete last group

Key Takeaway

🎯 Key Insight: Process strings in fixed-size chunks and pad only the final incomplete group

Asked in

A Amazon 15 M Microsoft 12

The key insight is to process the string in chunks of size k and pad only the final group if needed. The optimal approach uses direct string slicing which is more efficient than character-by-character processing. Time: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Character by Character	O(n)	O(n)	Process each character individually and build groups one character at a time
Optimized - Direct String Slicing	O(n)	O(n)	Use string slicing to extract groups directly without character-by-character processing

Brute Force - Character by Character — Algorithm Steps

Initialize empty result array and current group
For each character, add to current group
When group size reaches k, add to result and start new group
After processing all characters, pad last group if incomplete

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty result and current group

Process Each Character

Add characters to current group until size k

Complete Groups

Move full groups to result, pad incomplete last group

Code -

solution.c — C

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

void solution(char* s, int k, char fill, char result[][1001], int* count) {
    int len = strlen(s);
    int groupIndex = 0;
    int charIndex = 0;
    
    for (int i = 0; i < len; i++) {
        result[groupIndex][charIndex++] = s[i];
        
        if (charIndex == k) {
            result[groupIndex][charIndex] = '\0';
            groupIndex++;
            charIndex = 0;
        }
    }
    
    // Handle last incomplete group
    if (charIndex > 0) {
        while (charIndex < k) {
            result[groupIndex][charIndex++] = fill;
        }
        result[groupIndex][charIndex] = '\0';
        groupIndex++;
    }
    
    *count = groupIndex;
}

int main() {
    char s[1001], fill;
    int k;
    char result[1000][1001];
    int count;
    
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    scanf("%d", &k);
    scanf(" %c", &fill);
    
    solution(s, k, fill, result, &count);
    
    printf("[");
    for (int i = 0; i < count; i++) {
        printf("\"%s\"", result[i]);
        if (i < count - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string with constant time operations per character

✓ Linear Growth

Space Complexity

O(n)

Store result array and temporary group strings

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Character by Character — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler