Watch 10 video solutions for Divide a String Into Groups of Size k, a easy level problem involving String, Simulation. This walkthrough by codestorywithMIK has 4,148 views views. Want to try solving it yourself? Practice on FleetCode or read the detailed text solution.
A string s can be partitioned into groups of size k using the following procedure:
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.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.
Example 1:
Input: s = "abcdefghi", k = 3, fill = "x" Output: ["abc","def","ghi"] Explanation: The first 3 characters "abc" form the first group. The next 3 characters "def" form the second group. The last 3 characters "ghi" form the third group. Since all groups can be completely filled by characters from the string, we do not need to use fill. Thus, the groups formed are "abc", "def", and "ghi".
Example 2:
Input: s = "abcdefghij", k = 3, fill = "x" Output: ["abc","def","ghi","jxx"] Explanation: Similar to the previous example, we are forming the first three groups "abc", "def", and "ghi". For the last group, we can only use the character 'j' from the string. To complete this group, we add 'x' twice. Thus, the 4 groups formed are "abc", "def", "ghi", and "jxx".
Constraints:
1 <= s.length <= 100s consists of lowercase English letters only.1 <= k <= 100fill is a lowercase English letter.Problem Overview: You are given a string s, an integer k, and a fill character. Split the string into consecutive groups of length k. If the final group has fewer than k characters, pad it with the fill character until the group size becomes k.
The task is mostly a straightforward string manipulation problem. You iterate over the string in fixed-size chunks, build substrings, and ensure the final chunk has exactly k characters.
Approach 1: Using Loop and Substring (O(n) time, O(n) space)
Iterate through the string with a step size of k. At each step, extract a substring from index i to i + k. If the substring length is already k, add it directly to the result list. If the substring is shorter than k, append the fill character repeatedly until its length becomes k. This approach relies on basic substring extraction and array/list storage.
The key insight is that you never need complex data structures. Each character in the string is processed exactly once, which keeps the time complexity linear. The algorithm fits well into a simple simulation pattern where you emulate the grouping process step by step.
Approach 2: List Comprehension with Padding (O(n) time, O(n) space)
This variation is more concise in languages like Python or JavaScript. First compute all substrings of length k using slicing inside a list comprehension or array mapping step. For the last group, check if its length is smaller than k. If so, append the required number of fill characters using string multiplication or repeat operations.
The logic remains identical to the loop-based approach but compresses the iteration and substring creation into a single expression. The padding step ensures the last group always meets the size requirement. Under the hood, you still iterate over the string once and build the output list.
Both solutions operate in O(n) time because each character of the string is visited at most once. The extra space complexity is also O(n) because the resulting list of groups stores all characters again.
Recommended for interviews: The loop and substring approach is the most expected solution. It clearly demonstrates control over indexing, substring extraction, and edge case handling for the final group. The list comprehension version is shorter but may hide the logic during interviews. Start with the explicit loop to show clarity, then mention the concise version if the interviewer asks about code optimization.
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Loop with Substring Extraction | O(n) | O(n) | Best general solution. Clear indexing logic and easy to implement in any language. |
| List Comprehension with Padding | O(n) | O(n) | Useful in Python or JavaScript for concise code when readability is still acceptable. |