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.
This approach involves iterating through the string in increments of k and forming each group by taking k characters. If the number of characters left is less than k and a fill character is required, we append the fill character accordingly to complete the group.
The C code utilizes the printf function to extract substrings of size k from the input string s. It uses the integer division method to determine how many full groups are required. For the remainder of the string that does not fill an entire group, the fill character is appended until the group is complete.
Time Complexity: O(n), where n is the length of the string s.
Space Complexity: O(1), as no extra space other than a few variables is used.
This approach builds on modern language features such as list comprehensions and string formatting to achieve a succinct solution. By leveraging these tools, we can split the string into fixed-sized parts and adjust any part that doesn't meet the required size through padding.
In this Python solution, a list comprehension generates each group. The slice is padded with fill charaacters, but only up to a length of k, to ensure that every group is the correct size.
Python
JavaScript
Time Complexity: O(n), where n is the length of the string s.
Space Complexity: O(n/k), due to list storage.
We can directly simulate the process described in the problem statement, dividing the string s into groups of length k. For the last group, if it contains fewer than k characters, we use the character fill to pad it.
The time complexity is O(n), and the space complexity is O(n), where n is the length of the string s.
Python
Java
C++
Go
TypeScript
| Approach | Complexity |
|---|---|
| Using Loop and Substring | Time Complexity: O(n), where n is the length of the string s. |
| Using List Comprehension and Padding | Time Complexity: O(n), where n is the length of the string s. |
| Simulation | — |
| 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. |
Divide a String Into Groups of Size k | Easy | Leetcode 2138 | codestorywithMIK • codestorywithMIK • 4,148 views views
Watch 9 more video solutions →Practice Divide a String Into Groups of Size k with our built-in code editor and test cases.
Practice on FleetCode