Easy

题目描述

可以使用以下过程将字符串 s 分成大小为 k 的组：

  • 第一组由字符串的前 k 个字符组成，第二组由字符串的下 k 个字符组成，依此类推。每个字符最多只能是一个组的一部分。
  • 对于最后一组，如果字符串没有足够的字符剩余，则用字符 fill 来完成该组。

请注意，在去除最后一个组的填充字符（如果它存在的话）并按顺序连接所有的组后，所得到的字符串应该是 s。

给你字符串 s，每组的长度 k 和一个用来填充的字符 fill，请你返回一个字符串数组，该数组表示 s 分组后 每个组的组成情况 。

示例 1：

输入：s = "abcdefghi", k = 3, fill = "x"
输出：["abc","def","ghi"]
解释：
前 3 个字符 "abc" 形成第一组。
接下来的 3 个字符 "def" 形成第二组。
最后 3 个字符 "ghi" 形成第三组。
由于所有组都可以由字符串中的字符完全填充，所以不需要使用填充字符。
因此，形成的组是 "abc"、"def" 和 "ghi"。

示例 2：

输入：s = "abcdefghij", k = 3, fill = "x"
输出：["abc","def","ghi","jxx"]
解释：
与前面的例子类似，我们形成前三组 "abc"、"def" 和 "ghi"。
对于最后一组，我们只能使用字符串中的字符 'j'。为了补全这个组，我们添加 'x' 两次。
因此，形成的 4 组是 "abc"、"def"、"ghi" 和 "jxx"。

提示：

  • 1 <= s.length <= 100
  • s 仅由小写英文字母组成
  • 1 <= k <= 100
  • fill 是一个小写英文字母

解题思路

这道题的思路非常直观，就是模拟字符串分组的过程。

基本思路：

  1. 从字符串的开头开始，每次取 k 个字符作为一组
  2. 如果最后一组不足 k 个字符，用 fill 字符补齐
  3. 将所有组存入结果数组

具体实现步骤：

  1. 计算总共需要多少个组：(s.length + k - 1) / k，这是向上取整的技巧
  2. 遍历每个组的起始位置：i * k
  3. 对于每个组，取从当前位置开始的 k 个字符（如果不足则取剩余所有字符）
  4. 如果当前组长度不足 k，用 fill 字符补齐到 k 个字符

时间复杂度： O(n)，其中 n 是字符串长度，需要遍历所有字符一次 空间复杂度： O(1)，不考虑结果数组的额外空间

这种方法简单直接，代码清晰易懂，是最优的解法。

代码实现

class Solution {
public:
    vector<string> divideString(string s, int k, char fill) {
        vector<string> result;
        int n = s.length();
        
        for (int i = 0; i < n; i += k) {
            string group = s.substr(i, k);
            
            // 如果最后一组不足k个字符，用fill补齐
            while (group.length() < k) {
                group += fill;
            }
            
            result.push_back(group);
        }
        
        return result;
    }
};

class Solution:
    def divideString(self, s: str, k: int, fill: str) -> List[str]:
        result = []
        n = len(s)
        
        for i in range(0, n, k):
            group = s[i:i+k]
            
            # 如果最后一组不足k个字符，用fill补齐
            if len(group) < k:
                group += fill * (k - len(group))
            
            result.append(group)
        
        return result

public class Solution {
    public string[] DivideString(string s, int k, char fill) {
        List<string> result = new List<string>();
        int n = s.Length;
        
        for (int i = 0; i < n; i += k) {
            string group = s.Substring(i, Math.Min(k, n - i));
            
            // 如果最后一组不足k个字符，用fill补齐
            while (group.Length < k) {
                group += fill;
            }
            
            result.Add(group);
        }
        
        return result.ToArray();
    }
}

var divideString = function(s, k, fill) {
    const result = [];
    const n = s.length;
    
    for (let i = 0; i < n; i += k) {
        let group = s.substring(i, i + k);
        
        // 如果最后一组不足k个字符，用fill补齐
        while (group.length < k) {
            group += fill;
        }
        
        result.push(group);
    }
    
    return result;
};
在 LeetCode 上运行： 力扣中文版 LeetCode 国际版

复杂度分析

复杂度类型复杂度说明
时间复杂度O(n)需要遍历字符串的所有字符一次，其中 n 为字符串长度
空间复杂度O(1)不考虑结果数组的情况下，只使用常数额外空间

相关题目