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 = 4
Output: 4
Explanation: 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 = 1
Output: 1
Explanation: 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^th position, if the character at that index is smaller than the K^th character of the string, and 
  • Mark 1 in a greater vector at the i^th position if the character is greater than the K^th character of the string.
• Create a difference array that stores the difference of smaller and greater for each i^th position.
• 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.
• In the end, return val1 – val2 – val3, which is the count of substrings with equally smaller and greater elements that contain K^th character.

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)