力扣——830. 较大分组的位置（Java、JavaScript、C、C++实现四个百分百击败用户用时，含解析）

830. 较大分组的位置
     在一个由小写字母构成的字符串 s 中，包含由一些连续的相同字符所构成的分组。

例如，在字符串 s = “abbxxxxzyy” 中，就含有 “a”, “bb”, “xxxx”, “z” 和 “yy” 这样的一些分组。

分组可以用区间 [start, end] 表示，其中 start 和 end 分别表示该分组的起始和终止位置的下标。上例中的 “xxxx” 分组用区间表示为 [3,6] 。

我们称所有包含大于或等于三个连续字符的分组为 较大分组 。

找到每一个 较大分组 的区间，按起始位置下标递增顺序排序后，返回结果。

示例 1：

输入：s = “abbxxxxzzy”
输出：[[3,6]]
解释：“xxxx” 是一个起始于 3 且终止于 6 的较大分组。

示例 2：

输入：s = “abc”
输出：[]
解释：“a”,“b” 和 “c” 均不是符合要求的较大分组。

示例 3：

输入：s = “abcdddeeeeaabbbcd”
输出：[[3,5],[6,9],[12,14]]
解释：较大分组为 “ddd”, “eeee” 和 “bbb”

示例 4：

输入：s = “aba”
输出：[]

class Solution {
    public List<List<Integer>> largeGroupPositions(String s) {
        List<List<Integer>> ret = new ArrayList<List<Integer>>();
        int n = s.length();
        int num = 1;
        for (int i = 0; i < n; i++) {
            if (i == n - 1 || s.charAt(i) != s.charAt(i + 1)) {
                if (num >= 3) {
                    ret.add(Arrays.asList(i - num + 1, i));
                }
                num = 1;
            } else {
                num++;
            }
        }
        return ret;
    }
}

Java代码2：

class Solution {
    public List<List<Integer>> largeGroupPositions(String s) {
        List<List<Integer>> res = new ArrayList<>();
        int left = 0;//相同字符串左边边界
        int length = s.length();
        while (left < length) {
            int count = 0;//相同字符串的长度
            //统计相同字符串的长度
            while (left + count < length && s.charAt(left) == s.charAt(left + count))
                count++;
            //如果长度大于等于3，就把他加入到res中
            if (count >= 3)
                res.add(Arrays.asList(left, left + count - 1));
            //更新下一个字符串的左边边界
            left = left + count;
        }
        return res;
    }
    }

JavaScript代码：

var largeGroupPositions = function(s) {
    const ret = [];
    const n = s.length;
    let num = 1;
    for (let i = 0; i < n; i++) {
        if (i === n - 1 || s[i] !== s[i + 1]) {
            if (num >= 3) {
                ret.push([i - num + 1, i]);
            }
            num = 1;
        } else {
            num++;
        }
    }
    return ret;
};

C代码：

int** largeGroupPositions(char* s, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    int n = strlen(s);
    int** ret = malloc(sizeof(int*) * (n / 3));
    *returnColumnSizes = malloc(sizeof(int) * (n / 3));
    int num = 1;
    for (int i = 0; i < n; i++) {
        if (i == n - 1 || s[i] != s[i + 1]) {
            if (num >= 3) {
                int* tmp = malloc(sizeof(int) * 2);
                tmp[0] = i - num + 1, tmp[1] = i;
                (*returnColumnSizes)[*returnSize] = 2;
                ret[(*returnSize)++] = tmp;
            }
            num = 1;
        } else {
            num++;
        }
    }
    return ret;
}

C++代码：

class Solution {
public:
    vector<vector<int>> largeGroupPositions(string s) {
        vector<vector<int>> ans;
        int start = 0, end = 0;
        while(end < s.size()){
            if(s[start] != s[end+1]){
                if(end - start >= 2){
                    ans.push_back({start, end});
                }
                start = end + 1;
            }
            end ++;
        }
        return ans;
    }
};

作者：KJ.JK
本文仅用于交流学习，未经作者允许，禁止转载，更勿做其他用途，违者必究。
文章对你有所帮助的话，欢迎给个赞或者 star，你的支持是对作者最大的鼓励，不足之处可以在评论区多多指正，交流学习