Given a string S consisting of lowercase English letters of size N where (1 <= N <= 105), the task is to print the sum of the count of distinct characters N where (1 <= N <= 105)in all the substrings.
Examples:
Input: str = “abbca”
Output: 28
Explanation: The following are the substrings of “abbca”:
=> Sum of distinct characters in Substrings of length 1: “a”, “b”, “b”, “c”, “a” is 1 + 1 + 1 + 1 + 1 = 5
=> Sum of distinct characters in Substrings of length 2: “ab”, “bb”, “bc”, “ca” is 2 + 1 + 2 + 2 = 7.
=> Sum of distinct characters in Substrings of length 3: “abb”, “bbc”, “bca” is 2 + 2 + 3 = 7.
=> Sum of distinct characters in Substrings of length 4: “abbc”, “bbca” is 3 + 3 = 6.
=> Sum of distinct characters in Substrings of length 5: “abbca” is 3
The total count is 5 + 7 + 7 + 6 + 3 = 28Input: str = “code”
Output: 20
Explanation: The following are the substrings of “code”:
=> Sum of distinct characters in Substrings of length 1: “c”, “o”, “d”, “e” is 1 + 1 + 1 + 1 = 4.
=> Sum of distinct characters in Substrings of length 2: “co”, “od”, “de” is 2 + 2 + 2 = 6.
=> Sum of distinct characters in Substrings of length 3: “cod”, “ode” is 3 + 3 = 6.
=> Sum of distinct characters in Substrings of length 4: “code” is 4.
The total count is 4+ 6 + 6 + 4 = 20
Approach: To solve the problem follow the below idea:
The idea is to count the contribution of each character in different substrings. For each character ch, iterate through the entire string and for each index i, we will count the number of substrings ending at i and have at least one occurrence of ch. This can be simply done by keeping track of the last occurrence of ch.
- Initialize a variable result with 0 to store the answer.
-
Iterates through each lowercase English alphabet character from ‘a‘ to ‘z’.
- For each character, initializes a variable last_occur to -1, this will keep track of the position of the last occurrence of the current character in the string.
-
Iterates through input string S and checks if the S[i] matches the current character being considered.
- If matches, it adds the 1-based index of the character to the result as these many substrings have at least one current alphabets and updates last_occur to the current position.
- If not matches, it adds the position of the last occurrence of the current character (stored in last_occur) to the result.
- Final return the result
Below is the implementation of the above approach:
// C++ code for the above approach #include <bits/stdc++.h> using namespace std;
// Function to calculate answer // for a given string long long fun(string s)
{ // Get the length of the input string
int n = s.size();
// Initialize the result to 0
long long result = 0;
// Loop through each lowercase character
for ( char ch = 'a' ; ch <= 'z' ; ch++) {
// Initialize the last occurrence of the
// character to -1
int last_occur = -1;
// Loop through the input string
for ( int i = 0; i < n; i++) {
if (s[i] == ch) {
// If the current character matches
// the current alphabet character,
// add the position of the character
// (1-based index) to the result
result += (i + 1);
// Update the last
// occurrence position
last_occur = i;
}
else {
// If the current character
// doesn't match the current
// alphabet character, add the
// position of the last occurrence
// (if any) to the result
result += (last_occur + 1);
}
}
}
// Return the final result
return result;
} // Drivers code int main()
{ // Define an input string
string s = "abbca" ;
// Call the function and print the result
cout << fun(s);
return 0;
} |
// Java code for the above approach public class GFG {
// Function to calculate the answer for a given string
static long fun(String s)
{
// Get the length of the input string
int n = s.length();
// Initialize the result to 0
long result = 0 ;
// Loop through each lowercase character
for ( char ch = 'a' ; ch <= 'z' ; ch++) {
// Initialize the last occurrence of the
// character to -1
int lastOccur = - 1 ;
// Loop through the input string
for ( int i = 0 ; i < n; i++) {
if (s.charAt(i) == ch) {
// If the current character matches the
// current alphabet character, add the
// position of the character (1-based
// index) to the result
result += (i + 1 );
// Update the last occurrence position
lastOccur = i;
}
else {
// If the current character doesn't
// match the current alphabet character,
// add the position of the last
// occurrence (if any) to the result
result += (lastOccur + 1 );
}
}
}
// Return the final result
return result;
}
public static void main(String[] args)
{
// Define an input string
String s = "abbca" ;
// Call the function and print the result
System.out.println(fun(s));
}
} // This code is contributed by Taranpreet Singh. |
def fun(s):
# Get the length of the input string
n = len (s)
# Initialize the result to 0
result = 0
# Loop through each lowercase character
for ch in range ( ord ( 'a' ), ord ( 'z' ) + 1 ):
ch = chr (ch)
# Initialize the last occurrence of the character to -1
last_occur = - 1
# Loop through the input string
for i in range (n):
if s[i] = = ch:
# If the current character matches the current alphabet character,
# add the position of the character (1-based index) to the result
result + = (i + 1 )
# Update the last occurrence position
last_occur = i
else :
# If the current character doesn't match the current alphabet character,
# add the position of the last occurrence (if any) to the result
result + = (last_occur + 1 )
# Return the final result
return result
# Driver code s = "abbca"
print (fun(s))
#Contributed by Aditi Tyagi |
using System;
class Program
{ // Function to calculate the answer for a given string
static long Fun( string s)
{
// Get the length of the input string
int n = s.Length;
// Initialize the result to 0
long result = 0;
// Loop through each lowercase character
for ( char ch = 'a' ; ch <= 'z' ; ch++)
{
// Initialize the last occurrence of the character to -1
int last_occur = -1;
// Loop through the input string
for ( int i = 0; i < n; i++)
{
if (s[i] == ch)
{
// If the current character matches the current alphabet character,
// add the position of the character (1-based index) to the result
result += (i + 1);
// Update the last occurrence position
last_occur = i;
}
else
{
// If the current character doesn't match the current alphabet character,
// add the position of the last occurrence (if any) to the result
result += (last_occur + 1);
}
}
}
// Return the final result
return result;
}
// Main method
static void Main()
{
// Define an input string
string s = "abbca" ;
// Call the function and print the result
Console.WriteLine(Fun(s));
}
} |
// Function to calculate the answer for a given string function fun(s) {
// Get the length of the input string
const n = s.length;
// Initialize the result to 0
let result = 0;
// Loop through each lowercase character
for (let ch = 'a' ; ch <= 'z' ; ch = String.fromCharCode(ch.charCodeAt(0) + 1)) {
// Initialize the last occurrence of the character to -1
let lastOccur = -1;
// Loop through the input string
for (let i = 0; i < n; i++) {
if (s[i] === ch) {
// If the current character matches the current alphabet character,
// add the position of the character (1-based index) to the result
result += (i + 1);
// Update the last occurrence position
lastOccur = i;
} else {
// If the current character doesn't match the current alphabet character,
// add the position of the last occurrence (if any) to the result
result += (lastOccur + 1);
}
}
}
// Return the final result
return result;
} // Main method function main() {
// Define an input string
const s = "abbca" ;
// Call the function and print the result
console.log(fun(s));
} // Call the main method to start the program main(); |
28
Time Complexity: O(26*N), where N is the length of the input string.
Auxiliary Space: O(1)