# Count odd length Substrings with median same as Kth character of String

Given a string **S** of size **N**, the task is to find the number of substrings of odd lengths that have a median equal to the **K ^{th}** character of the string.

**Examples:**

Input:S = “ecadgg”, K = 4Output:4Explanation:Character at 4^{th}position in string is ‘d’.

Then there are 4 odd length substrings with ‘d’ as their median:

[d], [a, d, g], [e, c, a, d, g], therefore return 4 as the answer.

Input:s = “abc”, K = 1Output:1Explanation:Character at 1^{st}position in string is ‘a’. Then there is only 1 odd length substring with ‘a’ as its median: [a] therefore return 1 as the answer.

**Approach: **To solve the problem follow the below idea:

Median is middle element. So smaller elements has to be equal to number of bigger elements, the desired substrings would be like (S[K]) or (2 elements on left and right), (4 elements on left and right), so on. . . [cannot take 1, 3 . . . because the substring should have odd length]

- We can maintain smaller and bigger arrays of length N and populate them.
- This helps us to find in range [i, j] count of smaller and bigger elements with respect to S[K].

- For S[K] to be median in the range [i, j], the number of characters smaller than S[K] should be equal to the number of characters greater than S[K] and the subarray should include S[K].

Note:We are considering 1based indexing of string for understanding but the actual implementation uses 0 based indexing.

Follow the steps to solve the problem:

- Create two vectors namely greater and smaller of size N.
- Traverse the string:
- Mark 1 in a smaller vector at
**i**position, if the character at that index is smaller than the^{th}**K**character of the string, and^{th} - Mark 1 in a greater vector at the
**i**position if the character is greater than the^{th}**K**character of the string.^{th}

- Mark 1 in a smaller vector at
- Create a difference array that stores the difference of smaller and greater for each
**i**position.^{th} - Use prefix sum on difference array to find valid subarrays. In valid subarrays, the sum will be
**0**.- Use the prefix sum for the following three segments:
**start = 0**and**end = N**and store it in**val1**,**start = 0**and**end = K-1**store it in**val2**and**start = K**and**end = N**and store it in**val3**.

- Use the prefix sum for the following three segments:
- In the end, return
**val1 – val2 – val3**, which is the count of substrings with equally smaller and greater elements that contain**K**character.^{th}

Below is the implementation of the above approach.

## C++

// C++ code to implement the approach #include <bits/stdc++.h> using namespace std; // Function for finding the number of // sub strings in (start, end) where // sum of difference is zero int sum(int start, int end, vector<int>& v) { // STL map to store number of subarrays // starting from index zero having // particular value of sum. unordered_map<int, int> prevSum; int res = 0, currSum = 0; for (int i = start; i < end; i++) { // Add current element to sum so far. currSum += v[i]; // If currsum is equal to 0, then // a new subarray is found. // So increase count of subarrays. if (currSum == 0) res++; if (prevSum.find(currSum) != prevSum.end()) res += (prevSum[currSum]); // Add currsum value to count of // different values of sum. prevSum[currSum]++; } return res; } // Function to find odd length substrings // whose median is equal to s[k-1] int numberOfSubstrings(string& s, int k) { int n = s.size(); // Initializing vectors for storing // element is smaller or greater // than median vector<int> smaller(n, 0), greater(n, 0); for (int i = 0; i < n; i++) { smaller[i] = s[i] < s[k - 1]; greater[i] = s[i] > s[k - 1]; } // Declaring a vector to store // difference of greater and smaller // characters for each position vector<int> diff(n, 0); for (int i = 0; i < n; i++) diff[i] = smaller[i] - greater[i]; // Substrings in (0 to n) int val1 = sum(0, n, diff); // Substrings in (0 to k-1) int val2 = sum(0, k - 1, diff); // Substrings in (k to n) int val3 = sum(k, n, diff); // Considering only those sub strings // with difference 0 that // contains s[k-1] return val1 - val2 - val3; } // Driver code int main() { string S = "ecadgg"; int K = 4; // Function call cout << numberOfSubstrings(S, K); return 0; }

## Java

// Java code to implement the approach import java.io.*; import java.util.*; class GFG { // Function for finding the number of // sub strings in (start, end) where // sum of difference is zero public static int sum(int start, int end, int v[]) { // STL map to store number of subarrays // starting from index zero having // particular value of sum. HashMap<Integer, Integer> prevSum = new HashMap<Integer, Integer>(); int res = 0, currSum = 0; for (int i = start; i < end; i++) { // Add current element to sum so far. currSum += v[i]; // If currsum is equal to 0, then // a new subarray is found. // So increase count of subarrays. if (currSum == 0) res++; if (prevSum.containsKey(currSum)) { res += prevSum.get(currSum); prevSum.put(currSum, prevSum.get(currSum) + 1); } // Add currsum value to count of // different values of sum. prevSum.put(currSum, 1); } return res; } // Function to find odd length substrings // whose median is equal to s[k-1] public static int numberOfSubstrings(String s, int k) { int n = s.length(); // Initializing vectors for storing // element is smaller or greater // than median int smaller[] = new int[n]; int greater[] = new int[n]; for (int i = 0; i < n; i++) { smaller[i] = (s.charAt(i) < s.charAt(k - 1)) ? 1 : 0; greater[i] = (s.charAt(i) > s.charAt(k - 1)) ? 1 : 0; } // Declaring a vector to store // difference of greater and smaller // characters for each position int diff[] = new int[n]; for (int i = 0; i < n; i++) diff[i] = smaller[i] - greater[i]; // Substrings in (0 to n) int val1 = sum(0, n, diff); // Substrings in (0 to k-1) int val2 = sum(0, k - 1, diff); // Substrings in (k to n) int val3 = sum(k, n, diff); // Considering only those sub strings // with difference 0 that // contains s[k-1] return val1 - val2 - val3; } // Driver Code public static void main(String[] args) { String S = "ecadgg"; int K = 4; // Function call System.out.print(numberOfSubstrings(S, K)); } } // This code is contributed by Rohit Pradhan

## Python3

# Python code for the above approach # Function for finding the number of # sub strings in (start, end) where # sum of difference is zero def sum(start, end, v): # STL map to store number of subarrays # starting from index zero having # particular value of sum. prevSum = {}; res = 0 currSum = 0; for i in range(start, end): # Add current element to sum so far. currSum += v[i]; # If currsum is equal to 0, then # a new subarray is found. # So increase count of subarrays. if (currSum == 0): res += 1 if (currSum in prevSum): res += (prevSum[currSum]); # Add currsum value to count of # different values of sum. if (currSum in prevSum): prevSum[currSum] += 1 else: prevSum[currSum] = 1 return res; # Function to find odd length substrings # whose median is equal to s[k-1] def numberOfSubstrings(s, k): n = len(s) # Initializing vectors for storing # element is smaller or greater # than median smaller = [0] * n greater = [0] * n for i in range(n): smaller[i] = s[i] < s[k - 1]; greater[i] = s[i] > s[k - 1]; # Declaring a vector to store # difference of greater and smaller # characters for each position diff = [0] * n for i in range(n): diff[i] = smaller[i] - greater[i]; # Substrings in (0 to n) val1 = sum(0, n, diff); # Substrings in (0 to k-1) val2 = sum(0, k - 1, diff); # Substrings in (k to n) val3 = sum(k, n, diff); # Considering only those sub strings # with difference 0 that # contains s[k-1] return val1 - val2 - val3; # Driver code S = "ecadgg"; K = 4; # Function call print(numberOfSubstrings(S, K)); # This code is contributed by Saurabh Jaiswal

## C#

// C# code for the above approach using System; using System.Collections; using System.Collections.Generic; public class GFG { // Function for finding the number of // sub strings in (start, end) where // sum of difference is zero public static int sum(int start, int end, int[] v) { // Dictionary to store number of subarrays // starting from index zero having // particular value of sum. Dictionary<int, int> prevSum = new Dictionary<int, int>(); int res = 0, currSum = 0; for (int i = start; i < end; i++) { // Add current element to sum so far. currSum += v[i]; // If currsum is equal to 0, then // a new subarray is found. // So increase count of subarrays. if (currSum == 0) res++; if (prevSum.ContainsKey(currSum)) { res += prevSum[currSum]; prevSum[currSum] += 1; } // Add currsum value to count of // different values of sum. else { prevSum.Add(currSum, 1); } } return res; } // Function to find odd length substrings // whose median is equal to s[k-1] public static int numberOfSubstrings(String s, int k) { int n = s.Length; // Initializing vectors for storing // element is smaller or greater // than median int[] smaller = new int[n]; int[] greater = new int[n]; for (int i = 0; i < n; i++) { smaller[i] = (s[i] < s[k - 1]) ? 1 : 0; greater[i] = (s[i] > s[k - 1]) ? 1 : 0; } // Declaring a vector to store // difference of greater and smaller // characters for each position int[] diff = new int[n]; for (int i = 0; i < n; i++) diff[i] = smaller[i] - greater[i]; // Substrings in (0 to n) int val1 = sum(0, n, diff); // Substrings in (0 to k-1) int val2 = sum(0, k - 1, diff); // Substrings in (k to n) int val3 = sum(k, n, diff); // Considering only those sub strings // with difference 0 that // contains s[k-1] return val1 - val2 - val3; } static public void Main() { // Code String S = "ecadgg"; int K = 4; // Function call Console.Write(numberOfSubstrings(S, K)); } } // This code is contributed by lokeshmvs21.

## Javascript

<script> // JavaScript code for the above approach // Function for finding the number of // sub strings in (start, end) where // sum of difference is zero function sum(start, end, v) { // STL map to store number of subarrays // starting from index zero having // particular value of sum. let prevSum = new Map(); let res = 0, currSum = 0; for (let i = start; i < end; i++) { // Add current element to sum so far. currSum += v[i]; // If currsum is equal to 0, then // a new subarray is found. // So increase count of subarrays. if (currSum == 0) res++; if (prevSum.has(currSum)) res += (prevSum.get(currSum)); // Add currsum value to count of // different values of sum. if (prevSum.has(currSum)) prevSum.set(currSum, prevSum.get(currSum) + 1); else prevSum.set(currSum, 1); } return res; } // Function to find odd length substrings // whose median is equal to s[k-1] function numberOfSubstrings(s, k) { let n = s.length; // Initializing vectors for storing // element is smaller or greater // than median let smaller = new Array(n).fill(0), greater = new Array(n).fill(0); for (let i = 0; i < n; i++) { smaller[i] = s[i] < s[k - 1]; greater[i] = s[i] > s[k - 1]; } // Declaring a vector to store // difference of greater and smaller // characters for each position let diff = new Array(n).fill(0); for (let i = 0; i < n; i++) diff[i] = smaller[i] - greater[i]; // Substrings in (0 to n) let val1 = sum(0, n, diff); // Substrings in (0 to k-1) let val2 = sum(0, k - 1, diff); // Substrings in (k to n) let val3 = sum(k, n, diff); // Considering only those sub strings // with difference 0 that // contains s[k-1] return val1 - val2 - val3; } // Driver code let S = "ecadgg"; let K = 4; // Function call document.write(numberOfSubstrings(S, K)); // This code is contributed by Potta Lokesh </script>

**Output**

4

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

## Please

Loginto comment...