Skip to content
Related Articles

Related Articles

Improve Article

Print all positions of a given string having count of smaller characters equal on both sides

  • Last Updated : 20 Jul, 2021

Given a string, str, the task is to find the indices of the given string such that the count of lexicographically smaller characters on the left and right sides of that index is equal and non-zero.

Examples:

Input: str = “aabacdabbb” 
Output: 2 4 
Explanation: 
Count of smaller characters on the left side of index 2 is 2 and right side of index 2 is also 2. 
Count of smaller characters on the left side of index 4 is 4 and right side of index 4 is also 4. 
Therefore, the required output is 2 4. 

Input: “geeksforgeeks” 
Output: 5 
Explanation: 
Count of smaller characters on the left side of index 5 is 2 and right side of index 5 is also 2. 
Therefore, the required output is 5. 
 

Naive approach: The simplest approach to solve this problem is to traverse the given string and count the number of lexicographically smaller characters on the left side and right side of each index of the given string. For each index, check if the count of lexicographically smaller characters on the left side and right side of the current index is equal or not. If found to be true then print the current index.



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

Efficient Approach: To optimize the above approach the idea is to use Hashing. Follow the steps below to solve the problem:

  • Initialize an array, say cntFre[] to store the frequency of each character of the given string
  • Traverse the given string and store the frequency of each character of the given string.
  • Initialize an array, say cntLeftFreq[] to store the frequency of all the characters present on the left side of the current index of the given string.
  • Traverse the given string and store the frequency of all the lexicographically smaller characters present on the left side of the current index.
  • For each index, check if count of lexicographically smaller characters on the left side and the right side of the current index is equal or not. If found to be true then print the current index of the given string.

Below is the implementation of the above approach:

C++




// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find indexes
// of the given string that
// satisfy the condition
void printIndexes(string str)
{
    // Stores length of
    // given string
    int N = str.length();
     
    // Stores frequency of
    // each character of str
    int cntFreq[256] = {0};
     
    for (int i = 0; i < N;
                      i++) {
         
        // Update frequency of
        // current character
        cntFreq[str[i]]++;
         
    }
     
    // cntLeftFreq[i] Stores frequency
    // of characters present on
    // the left side of index i.
    int cntLeftFreq[256] = {0};
     
    // Traverse the given string
    for (int i = 0; i < N; i++) {
         
        // Stores count of smaller
        // characters on left side of i.
        int cntLeft = 0;
         
         
        // Stores count of smaller
        // characters on Right side of i.
        int cntRight = 0;
         
        // Traverse smaller characters
        // on left side of index i.
        for (int j = str[i] - 1;
                    j >= 0; j--) {
             
             
            // Update cntLeft  
            cntLeft += cntLeftFreq[j];
             
            // Update cntRight
            cntRight += cntFreq[j]
                   - cntLeftFreq[j];
        }
         
        // Update cntLeftFreq[str[i]]
        cntLeftFreq[str[i]]++;
         
        // If count of smaller elements
        // on both sides equal
        if (cntLeft == cntRight &&
                 cntLeft != 0) {
             
            // Print current index;
            cout<<i<<" ";
        }
          
    }
}
 
// Driver Code
int main()
{
    string str = "aabacdabbb";
    printIndexes(str);
}
Java



// Java program to implement
// the above approach
import java.util.*;
class GFG{
 
// Function to find indexes
// of the given String that
// satisfy the condition
static void printIndexes(char[] str)
{
  // Stores length of
  // given String
  int N = str.length;
 
  // Stores frequency of
  // each character of str
  int []cntFreq = new int[256];
 
  for (int i = 0; i < N; i++)
  {
    // Update frequency of
    // current character
    cntFreq[str[i]]++;
  }
 
  // cntLeftFreq[i] Stores frequency
  // of characters present on
  // the left side of index i.
  int []cntLeftFreq = new int[256];
 
  // Traverse the given String
  for (int i = 0; i < N; i++)
  {
    // Stores count of smaller
    // characters on left side of i.
    int cntLeft = 0;
 
    // Stores count of smaller
    // characters on Right side of i.
    int cntRight = 0;
 
    // Traverse smaller characters
    // on left side of index i.
    for (int j = str[i] - 1;
             j >= 0; j--)
    {
      // Update cntLeft  
      cntLeft += cntLeftFreq[j];
 
      // Update cntRight
      cntRight += cntFreq[j] -
                  cntLeftFreq[j];
    }
 
    // Update cntLeftFreq[str[i]]
    cntLeftFreq[str[i]]++;
 
    // If count of smaller elements
    // on both sides equal
    if (cntLeft == cntRight &&
        cntLeft != 0)
    {
      // Print current index;
      System.out.print(i + " ");
    }
  }
}
 
// Driver Code
public static void main(String[] args)
{
  String str = "aabacdabbb";
  printIndexes(str.toCharArray());
}
}
 
// This code is contributed by gauravrajput1
Python3



# Python3 program to implement
# the above approach
 
# Function to find indexes
# of the given that
# satisfy the condition
def printIndexes(strr):
     
    # Stores length of
    # given string
    N = len(strr)
 
    # Stores frequency of
    # each character of strr
    cntFreq = [0] * 256
 
    for i in range(N):
         
        # Update frequency of
        # current character
        cntFreq[ord(strr[i])] += 1
 
    # cntLeftFreq[i] Stores frequency
    # of characters present on
    # the left side of index i.
    cntLeftFreq = [0] * 256
     
    # Traverse the given string
    for i in range(N):
 
        # Stores count of smaller
        # characters on left side of i.
        cntLeft = 0
 
        # Stores count of smaller
        # characters on Right side of i.
        cntRight = 0
 
        # Traverse smaller characters
        # on left side of index i.
        for j in range(ord(strr[i]) - 1, -1, -1):
             
            # Update cntLeft
            cntLeft += cntLeftFreq[j]
 
            # Update cntRight
            cntRight += (cntFreq[j] -
                     cntLeftFreq[j])
 
        # Update cntLeftFreq[strr[i]]
        cntLeftFreq[ord(strr[i])] += 1
 
        # If count of smaller elements
        # on both sides equal
        if (cntLeft == cntRight and cntLeft != 0):
 
            # Print current index
            print(i, end = " ")
 
# Driver Code
if __name__ == '__main__':
     
    strr = "aabacdabbb"
     
    printIndexes(strr)
 
# This code is contributed by mohit kumar 29
C#



// C# program to implement
// the above approach
using System;
 
class GFG{
 
// Function to find indexes
// of the given string that
// satisfy the condition
static void printIndexes(char[] str)
{
   
  // Stores length of
  // given string
  int N = str.Length;
 
  // Stores frequency of
  // each character of str
  int []cntFreq = new int[256];
 
  for(int i = 0; i < N; i++)
  {
     
    // Update frequency of
    // current character
    cntFreq[str[i]]++;
  }
 
  // cntLeftFreq[i] Stores frequency
  // of characters present on
  // the left side of index i.
  int []cntLeftFreq = new int[256];
 
  // Traverse the given string
  for(int i = 0; i < N; i++)
  {
     
    // Stores count of smaller
    // characters on left side of i.
    int cntLeft = 0;
 
    // Stores count of smaller
    // characters on Right side of i.
    int cntRight = 0;
 
    // Traverse smaller characters
    // on left side of index i.
    for(int j = str[i] - 1;
            j >= 0; j--)
    {
       
      // Update cntLeft  
      cntLeft += cntLeftFreq[j];
 
      // Update cntRight
      cntRight += cntFreq[j] -
                  cntLeftFreq[j];
    }
 
    // Update cntLeftFreq[str[i]]
    cntLeftFreq[str[i]]++;
 
    // If count of smaller elements
    // on both sides equal
    if (cntLeft == cntRight &&
        cntLeft != 0)
    {
       
      // Print current index;
      Console.Write(i + " ");
    }
  }
}
 
// Driver Code
public static void Main()
{
  string str = "aabacdabbb";
   
  printIndexes(str.ToCharArray());
}
}
 
// This code is contributed by SURENDRA_GANGWAR
Javascript



<script>
 
// JavaScript program to implement
// the above approach
 
// Function to find indexes
// of the given string that
// satisfy the condition
function printIndexes(str)
{
    // Stores length of
    // given string
    var N = str.length;
     
    // Stores frequency of
    // each character of str
    var cntFreq = Array(256).fill(0);
     
    for (var i = 0; i < N;
                      i++) {
         
        // Update frequency of
        // current character
        cntFreq[str[i].charCodeAt(0)]++;
         
    }
     
    // cntLeftFreq[i] Stores frequency
    // of characters present on
    // the left side of index i.
    var cntLeftFreq = Array(256).fill(0);
     
    // Traverse the given string
    for (var i = 0; i < N; i++) {
         
        // Stores count of smaller
        // characters on left side of i.
        var cntLeft = 0;
         
         
        // Stores count of smaller
        // characters on Right side of i.
        var cntRight = 0;
         
        // Traverse smaller characters
        // on left side of index i.
        for (var j = str[i].charCodeAt(0) - 1;
                    j >= 0; j--) {
             
             
            // Update cntLeft  
            cntLeft += cntLeftFreq[j];
             
            // Update cntRight
            cntRight += cntFreq[j]
                   - cntLeftFreq[j];
        }
         
        // Update cntLeftFreq[str[i]]
        cntLeftFreq[str[i].charCodeAt(0)]++;
         
        // If count of smaller elements
        // on both sides equal
        if (cntLeft == cntRight &&
                 cntLeft != 0) {
             
            // Print current index;
            document.write( i + " ");
        }
          
    }
}
 
// Driver Code
var str = "aabacdabbb";
printIndexes(str);
 
 
</script>
Output: 
2 4
 
Time Complexity: O(N * 256)
Auxiliary Space: O(256)
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.



My Personal Notes
arrow_drop_up
Previous
Minimize cost of choosing and skipping array elements to reach end of the given array
Next

Count array elements with rank not exceeding K
Recommended Articles
Page :
Count right angled triangles in a matrix having two of its sides parallel to sides of the matrix
16, Oct 20
Count positions in Binary Matrix having equal count of set bits in corresponding row and column
01, Oct 20
Array Index with same count of even or odd numbers on both sides
12, Feb 18
Count ways to partition a string such that both parts have equal distinct characters
08, Apr 20
Count strings from given array having all characters appearing in a given string
17, Dec 20
Count numbers in a given range having prime and non-prime digits at prime and non-prime positions respectively
15, Jan 21
Print the arranged positions of characters to make palindrome
13, Mar 18
Minimize swaps of same-indexed characters to make sum of ASCII value of characters of both the strings odd
10, Feb 21
Check if a string can be made palindromic by swapping pairs of characters from indices having unequal characters in a Binary String
31, Mar 21
Rearrange the Array to maximize the elements which is smaller than both its adjacent elements
24, Jun 21
Minimize cost to make all characters of a Binary String equal to '1' by reversing or flipping characters of substrings
11, Jun 21
Count of binary strings of length N having equal count of 0's and 1's and count of 1's ≥ count of 0's in each prefix substring
25, Jul 20
Count levels in a Binary Tree consisting of node values having set bits at different positions
29, Jan 21
Number of Positions to partition the string such that atleast m characters with same frequency are present in each substring
17, Apr 19
Count characters of a string which when removed individually makes the string equal to another string
09, Jun 21
Count decrements to nearest smaller element required to make all array elements equal
03, Nov 20
Check whether two strings can be made equal by reversing substring of equal length from both strings
15, Jul 20
Check if both halves of the string have same set of characters
05, Jul 17
Check if both halves of the string have same set of characters in Python
03, Dec 17
Partition the string in two parts such that both parts have at least k different characters
03, Jul 19
Count of lexicographically smaller characters on right
15, Feb 20
Count strings having sum of ASCII values of characters equal to a Prime or Armstrong Number
03, Jun 21
Modify string by replacing all occurrences of given characters by specified replacing characters
14, Apr 21
Modify characters of a string by adding integer values of same-indexed characters from another given string
01, Mar 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
man_preet
@man_preet
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox