# Count substrings with different first and last characters

Given a string S, the task is to print the count of substrings from a given string whose first and last characters are different.

Examples:

Input: S = “abcab”
Output: 8
Explanation:
There are 8 substrings having first and last characters different {ab, abc, abcab, bc, bca, ca, cab, ab}.

Input: S = “aba”
Output: 2
Explanation:
There are 2 substrings having first and last characters different {ab, ba}.

Naive Approach: The idea is to generate all possible substrings of a given string and for each substring, check if the first and the last characters are different or not. If found to be true, then increment the count by 1 and check for the next substring. Print the count after traversal of all the substring.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Function to count the substrings ` `// having different first and last ` `// characters ` `int` `countSubstring(string s, ``int` `n) ` `{ ` `    ``// Store the final count ` `    ``int` `ans = 0; ` ` `  `    ``// Loop to traverse the string ` `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``// Counter for each iteration ` `        ``int` `cnt = 0; ` ` `  `        ``// Iterate over substrings ` `        ``for` `(``int` `j = i + 1; j < n; j++) { ` ` `  `            ``// Compare the characters ` `            ``if` `(s[j] != s[i]) ` ` `  `                ``// Increase count ` `                ``cnt++; ` `        ``} ` ` `  `        ``// Adding count of substrings ` `        ``// to the final count ` `        ``ans += cnt; ` `    ``} ` ` `  `    ``// Print the final count ` `    ``cout << ans; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``// Given string ` `    ``string S = ``"abcab"``; ` ` `  `    ``// Length of the string ` `    ``int` `N = 5; ` ` `  `    ``// Function Call ` `    ``countSubstring(S, N); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program for the above approach  ` `import` `java.util.*; ` `import` `java.lang.*; ` `import` `java.io.*; ` ` `  `class` `GFG{ ` `     `  `// Function to count the substrings ` `// having different first and last ` `// characters ` `static` `void` `countSubstring(String s, ``int` `n) ` `{ ` `     `  `    ``// Store the final count ` `    ``int` `ans = ``0``; ` ` `  `    ``// Loop to traverse the string ` `    ``for``(``int` `i = ``0``; i < n; i++) ` `    ``{ ` `         `  `        ``// Counter for each iteration ` `        ``int` `cnt = ``0``; ` ` `  `        ``// Iterate over substrings ` `        ``for``(``int` `j = i + ``1``; j < n; j++) ` `        ``{ ` `             `  `            ``// Compare the characters ` `            ``if` `(s.charAt(j) != s.charAt(i)) ` ` `  `                ``// Increase count ` `                ``cnt++; ` `        ``} ` ` `  `        ``// Adding count of substrings ` `        ``// to the final count ` `        ``ans += cnt; ` `    ``} ` ` `  `    ``// Print the final count ` `    ``System.out.print(ans); ` `} ` `     `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `     `  `    ``// Given string ` `    ``String S = ``"abcab"``; ` ` `  `    ``// Length of the string ` `    ``int` `N = ``5``; ` ` `  `    ``// Function call ` `    ``countSubstring(S, N); ` `} ` `} ` ` `  `// This code is contributed by code_hunt `

## Python3

 `# Python3 program for the above approach ` ` `  `# Function to count the substrings ` `# having different first and last ` `# characters ` `def` `countSubstring(s, n): ` ` `  `    ``# Store the final count ` `    ``ans ``=` `0` ` `  `    ``# Loop to traverse the string ` `    ``for` `i ``in` `range``(n): ` ` `  `        ``# Counter for each iteration ` `        ``cnt ``=` `0` ` `  `        ``# Iterate over substrings ` `        ``for` `j ``in` `range``(i ``+` `1``, n): ` ` `  `            ``# Compare the characters ` `            ``if` `(s[j] !``=` `s[i]): ` ` `  `                ``# Increase count ` `                ``cnt ``+``=` `1` `         `  `        ``# Adding count of substrings ` `        ``# to the final count ` `        ``ans ``+``=` `cnt ` `     `  `    ``# Print the final count ` `    ``print``(ans) ` ` `  `# Driver Code ` ` `  `# Given string ` `S ``=` `"abcab"` ` `  `# Length of the string ` `N ``=` `5` ` `  `# Function call ` `countSubstring(S, N) ` ` `  `# This code is contributed by code_hunt `

## C#

 `// C# program for the above approach ` `using` `System;  ` `using` `System.Collections;  ` `using` `System.Collections.Generic;  ` `using` `System.Text;  ` ` `  `class` `GFG{ ` `     `  `// Function to count the substrings ` `// having different first and last ` `// characters ` `static` `void` `countSubstring(``string` `s, ``int` `n) ` `{ ` `     `  `    ``// Store the final count ` `    ``int` `ans = 0; ` ` `  `    ``// Loop to traverse the string ` `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{ ` `         `  `        ``// Counter for each iteration ` `        ``int` `cnt = 0; ` ` `  `        ``// Iterate over substrings ` `        ``for``(``int` `j = i + 1; j < n; j++) ` `        ``{ ` `             `  `            ``// Compare the characters ` `            ``if` `(s[j] != s[i]) ` ` `  `                ``// Increase count ` `                ``cnt++; ` `        ``} ` ` `  `        ``// Adding count of substrings ` `        ``// to the final count ` `        ``ans += cnt; ` `    ``} ` ` `  `    ``// Print the final count ` `    ``Console.Write(ans); ` `} ` `     `  `// Driver Code ` `public` `static` `void` `Main(``string``[] args) ` `{ ` `     `  `    ``// Given string ` `    ``string` `S = ``"abcab"``; ` ` `  `    ``// Length of the string ` `    ``int` `N = 5; ` ` `  `    ``// Function call ` `    ``countSubstring(S, N); ` `} ` `} ` ` `  `// This code is contributed by rutvik_56 `

Output:

```8
```

Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized using Map by to store the frequency of the characters of the string. Follow the steps below to solve the problem:

1. Initialize two variables, one for counting different characters for every iteration (say cur) and one to store the final count of substrings (say ans).
2. Initialize a map M to store the frequency of all characters in it.
3. Traverse the given string and for each character, follow the steps below:
• Iterate the map M.
• If the first element i.e., the key of the map is not the same as the current character, then proceed.
• Otherwise, add the value corresponding to the current character.
4. After traversal of the Map, add cur to the final result i.e., ans += cur.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Function to count the substrings ` `// having different first & last character ` `int` `countSubstring(string s, ``int` `n) ` `{ ` `    ``// Stores frequency of each char ` `    ``map<``char``, ``int``> m; ` ` `  `    ``// Loop to store frequency of ` `    ``// the characters in a Map ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``m[s[i]]++; ` ` `  `    ``// To store final result ` `    ``int` `ans = 0; ` ` `  `    ``// Traversal of string ` `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``// Store answer for every ` `        ``// iteration ` `        ``int` `cnt = 0; ` `        ``m[s[i]]--; ` ` `  `        ``// Map traversal ` `        ``for` `(``auto` `value : m) { ` ` `  `            ``// Compare current char ` `            ``if` `(value.first == s[i]) { ` `                ``continue``; ` `            ``} ` `            ``else` `{ ` `                ``cnt += value.second; ` `            ``} ` `        ``} ` ` `  `        ``ans += cnt; ` `    ``} ` ` `  `    ``// Print the final count ` `    ``cout << ans; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``// Given string ` `    ``string S = ``"abcab"``; ` ` `  `    ``// Length of the string ` `    ``int` `N = 5; ` ` `  `    ``// Function Call ` `    ``countSubstring(S, N); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program for the above approach ` `import` `java.util.*; ` ` `  `class` `GFG{ ` ` `  `// Function to count the subStrings ` `// having different first & last character ` `static` `void` `countSubString(``char` `[]s, ``int` `n) ` `{ ` `     `  `    ``// Stores frequency of each char ` `    ``HashMap mp = ``new` `HashMap(); ` ` `  `    ``// Loop to store frequency of ` `    ``// the characters in a Map ` `    ``for``(``int` `i = ``0``; i < n; i++) ` ` `  `        ``if` `(mp.containsKey(s[i])) ` `        ``{ ` `            ``mp.put(s[i], mp.get(s[i]) + ``1``); ` `        ``} ` `        ``else` `        ``{ ` `            ``mp.put(s[i], ``1``); ` `        ``} ` ` `  `    ``// To store final result ` `    ``int` `ans = ``0``; ` ` `  `    ``// Traversal of String ` `    ``for``(``int` `i = ``0``; i < n; i++) ` `    ``{ ` `         `  `        ``// Store answer for every ` `        ``// iteration ` `        ``int` `cnt = ``0``; ` `        ``if` `(mp.containsKey(s[i])) ` `        ``{ ` `            ``mp.put(s[i], mp.get(s[i]) - ``1``); ` ` `  `            ``// Map traversal ` `            ``for``(Map.Entry value : mp.entrySet()) ` `            ``{ ` `                 `  `                ``// Compare current char ` `                ``if` `(value.getKey() == s[i]) ` `                ``{ ` `                    ``continue``; ` `                ``} ` `                ``else`  `                ``{ ` `                    ``cnt += value.getValue(); ` `                ``} ` `            ``} ` `            ``ans += cnt; ` `        ``} ` `    ``} ` `     `  `    ``// Print the final count ` `    ``System.out.print(ans); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `     `  `    ``// Given String ` `    ``String S = ``"abcab"``; ` ` `  `    ``// Length of the String ` `    ``int` `N = ``5``; ` ` `  `    ``// Function call ` `    ``countSubString(S.toCharArray(), N); ` `} ` `} ` ` `  `// This code is contributed by Amit Katiyar`

## C#

 `// C# program for the above approach ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG{ ` ` `  `// Function to count the subStrings ` `// having different first & last character ` `static` `void` `countSubString(``char` `[]s, ``int` `n) ` `{ ` `     `  `    ``// Stores frequency of each char ` `    ``Dictionary<``char``, ` `               ``int``> mp = ``new` `Dictionary<``char``, ` `                                        ``int``>(); ` ` `  `    ``// Loop to store frequency of ` `    ``// the characters in a Map ` `    ``for``(``int` `i = 0; i < n; i++) ` ` `  `        ``if` `(mp.ContainsKey(s[i])) ` `        ``{ ` `            ``mp[s[i]] = mp[s[i]] + 1; ` `        ``} ` `        ``else` `        ``{ ` `            ``mp.Add(s[i], 1); ` `        ``} ` ` `  `    ``// To store readonly result ` `    ``int` `ans = 0; ` ` `  `    ``// Traversal of String ` `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{ ` `         `  `        ``// Store answer for every ` `        ``// iteration ` `        ``int` `cnt = 0; ` `        ``if` `(mp.ContainsKey(s[i])) ` `        ``{ ` `            ``mp[s[i]] = mp[s[i]] - 1; ` ` `  `            ``// Map traversal ` `            ``foreach``(KeyValuePair<``char``, ` `                                 ``int``> value ``in` `mp) ` `            ``{ ` `                 `  `                ``// Compare current char ` `                ``if` `(value.Key == s[i]) ` `                ``{ ` `                    ``continue``; ` `                ``} ` `                ``else` `                ``{ ` `                    ``cnt += value.Value; ` `                ``} ` `            ``} ` `            ``ans += cnt; ` `        ``} ` `    ``} ` `     `  `    ``// Print the readonly count ` `    ``Console.Write(ans); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `     `  `    ``// Given String ` `    ``String S = ``"abcab"``; ` ` `  `    ``// Length of the String ` `    ``int` `N = 5; ` ` `  `    ``// Function call ` `    ``countSubString(S.ToCharArray(), N); ` `} ` `} ` ` `  `// This code is contributed by Amit Katiyar`

Output:

```8
```

Time Complexity: O(N*26)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.