Divide a String Into Groups of Size k

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

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

✓ Brute Force - Character by Character

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

Iterate through each character in the string, adding it to the current group. When a group reaches size k, start a new group. Fill the last group if needed.

Optimized - Direct String Slicing

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

Instead of building groups character by character, slice the string directly into chunks of size k. This reduces the number of string operations and is more efficient.

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