Description
Given a string s, return the number of homogenous substrings of s. Since the answer may be too large, return it modulo 109 + 7.
A string is homogenous if all the characters of the string are the same.
A substring is a contiguous sequence of characters within a string.
Example 1:
Input: s = "abbcccaa"
Output: 13
Explanation: The homogenous substrings are listed as below:
"a" appears 3 times.
"aa" appears 1 time.
"b" appears 2 times.
"bb" appears 1 time.
"c" appears 3 times.
"cc" appears 2 times.
"ccc" appears 1 time.
3 + 1 + 2 + 1 + 3 + 2 + 1 = 13.
Example 2:
Input: s = "xy"
Output: 2
Explanation: The homogenous substrings are "x" and "y".
Example 3:
Input: s = "zzzzz"
Output: 15
Constraints:
1 <= s.length <= 105s consists of lowercase letters.
Solutions
Solution 1
PythonJavaC++GoTypeScriptRustC#C
class Solution:
def countHomogenous(self, s: str) -> int:
mod = 10**9 + 7
i, n = 0, len(s)
ans = 0
while i < n:
j = i
while j < n and s[j] == s[i]:
j += 1
cnt = j - i
ans += (1 + cnt) * cnt // 2
ans %= mod
i = j
return ans(code-box)
class Solution {
private static final int MOD = (int) 1e9 + 7;
public int countHomogenous(String s) {
int n = s.length();
long ans = 0;
for (int i = 0, j = 0; i < n; i = j) {
j = i;
while (j < n && s.charAt(j) == s.charAt(i)) {
++j;
}
int cnt = j - i;
ans += (long) (1 + cnt) * cnt / 2;
ans %= MOD;
}
return (int) ans;
}
}(code-box)
class Solution {
public:
const int mod = 1e9 + 7;
int countHomogenous(string s) {
int n = s.size();
long ans = 0;
for (int i = 0, j = 0; i < n; i = j) {
j = i;
while (j < n && s[j] == s[i]) ++j;
int cnt = j - i;
ans += 1ll * (1 + cnt) * cnt / 2;
ans %= mod;
}
return ans;
}
};(code-box)
func countHomogenous(s string) (ans int) {
n := len(s)
const mod int = 1e9 + 7
for i, j := 0, 0; i < n; i = j {
j = i
for j < n && s[j] == s[i] {
j++
}
cnt := j - i
ans += (1 + cnt) * cnt / 2
ans %= mod
}
return
}(code-box)
function countHomogenous(s: string): number {
const mod = 1e9 + 7;
const n = s.length;
let ans = 0;
for (let i = 0, j = 0; j < n; j++) {
if (s[i] !== s[j]) {
i = j;
}
ans = (ans + j - i + 1) % mod;
}
return ans;
}(code-box)
impl Solution {
pub fn count_homogenous(s: String) -> i32 {
const MOD: usize = (1e9 as usize) + 7;
let s = s.as_bytes();
let n = s.len();
let mut ans = 0;
let mut i = 0;
for j in 0..n {
if s[i] != s[j] {
i = j;
}
ans = (ans + j - i + 1) % MOD;
}
ans as i32
}
}(code-box)
public class Solution {
public int CountHomogenous(string s) {
long MOD = 1000000007;
long ans = 0;
for (int i = 0, j = 0; i < s.Length; i = j) {
j = i;
while (j < s.Length && s[j] == s[i]) {
++j;
}
int cnt = j - i;
ans += (long) (1 + cnt) * cnt / 2;
ans %= MOD;
}
return (int) ans;
}
}(code-box)
int countHomogenous(char* s) {
int MOD = 1e9 + 7;
int ans = 0;
for (int i = 0, j = 0; s[j]; j++) {
if (s[i] != s[j]) {
i = j;
}
ans = (ans + j - i + 1) % MOD;
}
return ans;
}(code-box)
Solution 2
PythonJavaC++Go
class Solution:
def countHomogenous(self, s: str) -> int:
mod = 10**9 + 7
ans = cnt = 1
for a, b in pairwise(s):
cnt = cnt + 1 if a == b else 1
ans = (ans + cnt) % mod
return ans(code-box)
class Solution {
private static final int MOD = (int) 1e9 + 7;
public int countHomogenous(String s) {
int n = s.length();
int ans = 1, cnt = 1;
for (int i = 1; i < n; ++i) {
cnt = s.charAt(i) == s.charAt(i - 1) ? cnt + 1 : 1;
ans = (ans + cnt) % MOD;
}
return ans;
}
}(code-box)
class Solution {
public:
const int mod = 1e9 + 7;
int countHomogenous(string s) {
int n = s.size();
int ans = 1, cnt = 1;
for (int i = 1; i < n; ++i) {
cnt = s[i] == s[i - 1] ? cnt + 1 : 1;
ans = (ans + cnt) % mod;
}
return ans;
}
};(code-box)
func countHomogenous(s string) int {
n := len(s)
const mod int = 1e9 + 7
ans, cnt := 1, 1
for i := 1; i < n; i++ {
if s[i] == s[i-1] {
cnt++
} else {
cnt = 1
}
ans = (ans + cnt) % mod
}
return ans
}(code-box)
