Skip to content
Related Articles

Related Articles

Frequency of smallest character in first sentence less than that of second sentence

Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 14 Sep, 2022
Improve Article
Save Article

Given two array of strings, arr1[] and arr2[], the task is to count the number of strings in arr2[] whose frequency of the smallest characters is less than the frequency of the smallest character for each string in arr1[].

Examples: 

Input: arr1[] = {“cbd”}, arr2[] = {“zaaaz”} 
Output:
Explanation: 
The frequency of the smallest characters in “cbd” is 1 which is less than the frequency of the smallest characters in “zaaaz” which is 2. 
Therefore, the total count is 1 for the string “cbd”.

Input: arr1[] = {“yyy”,”zz”}, arr2[] = {“x”,”xx”,”xxx”,”xxxx”} 
Output: 1 2 
Explanation: 
1. The frequency of the smallest characters in “yyy” is 3 which is less than the frequency of the smallest characters in “xxxx” which is 4. 
Therefore, the total count is 1 for the string “yyy”. 
2. The frequency of the smallest characters in “zz” is 2 which is less than the frequency of the smallest characters in “xxx” and “xxxx” which is 3 and 4 respectively. 
Therefore, the total count is 2 for the string “zz”.  

Approach: This problem can be solved using Greedy Approach. Below are the steps: 
 

  1. For each string in the array, arr2[] count the frequency of the smallest characters and store it in the array (say freq[]).
  2. Sort the frequency array freq[].
  3. Now, for each string in the array arr1[] count the frequency of smallest characters in the string (say X).
  4. For each X, find the number of elements greater than X in freq[] using Binary Search by using the approach discussed this article.

Below is the implementation of the above approach: 

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to count the frequency of
// minimum character
int countMinFreq(string s)
{
 
    // Sort the string s
    sort(s.begin(), s.end());
 
    // Return the count with smallest
    // character
    return count(s.begin(), s.end(), s[0]);
}
 
// Function to count number of frequency
// of smallest character of string arr1[]
// is less than the string in arr2[]
void countLessThan(vector<string>& arr1,
                   vector<string>& arr2)
{
    // To store the frequency of smallest
    // character in each string of arr2
    vector<int> freq;
 
    // Traverse the arr2[]
    for (string s : arr2) {
 
        // Count the frequency of smallest
        // character in string s
        int f = countMinFreq(s);
 
        // Append the frequency to freq[]
        freq.push_back(f);
    }
 
    // Sort the frequency array
    sort(freq.begin(), freq.end());
 
    // Traverse the array arr1[]
    for (string s : arr1) {
 
        // Count the frequency of smallest
        // character in string s
        int f = countMinFreq(s);
 
        // find the element greater than f
        auto it = upper_bound(freq.begin(),
                              freq.end(), f);
 
        // Find the count such that
        // arr1[i] < arr2[j]
        int cnt = freq.size()
                  - (it - freq.begin());
 
        // Print the count
        cout << cnt << ' ';
    }
}
 
// Driver Code
int main()
{
 
    vector<string> arr1, arr2;
    arr1 = { "yyy", "zz" };
    arr2 = { "x", "xx", "xxx", "xxxx" };
 
    // Function Call
    countLessThan(arr1, arr2);
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
import java.util.*;
class GFG
{
 
  // Function to count the frequency of
  // minimum character
  static int countMinFreq(String s)
  {
 
    // Sort the string s
    char[] tempArray = s.toCharArray();
    Arrays.sort(tempArray);
    s = new String(tempArray);
 
    // Return the count with smallest
    // character
    int x = 0;
    for (int i = 0; i < s.length(); i++)
      if (s.charAt(i) == s.charAt(0))
        x++;
    return x;
  }
 
  // Function to count number of frequency
  // of smallest character of string arr1[]
  // is less than the string in arr2[]
  static void countLessThan(List<String> arr1,
                            List<String> arr2)
  {
 
    // To store the frequency of smallest
    // character in each string of arr2
    List<Integer> freq = new ArrayList<Integer>();
 
    // Traverse the arr2[]
    for (String s : arr2)
    {
 
      // Count the frequency of smallest
      // character in string s
      int f = countMinFreq(s);
 
      // Append the frequency to freq[]
      freq.add(f);
    }
 
    // Sort the frequency array
    Collections.sort(freq);
 
    // Traverse the array arr1[]
    for (String s : arr1) {
 
      // Count the frequency of smallest
      // character in string s
      int f = countMinFreq(s);
 
      // find the element greater than f
      int it = upper_bound(freq, f);
 
      // Find the count such that
      // arr1[i] < arr2[j]
      int cnt = freq.size() - it;
 
      // Print the count
      System.out.print(cnt + " ");
    }
  }
 
  static int upper_bound(List<Integer> freq, int f)
  {
    int low = 0, high = freq.size() - 1;
 
    while (low < high) {
      int mid = (low + high) / 2;
      if (freq.get(mid) > f)
        high = mid;
      else
        low = mid + 1;
    }
 
    return (freq.get(low) < f) ? low++ : low;
  }
 
  // Driver Code
  public static void main(String[] args)
  {
    List<String> arr1, arr2;
    arr1 = Arrays.asList(new String[] { "yyy", "zz" });
    arr2 = Arrays.asList(
      new String[] { "x", "xx", "xxx", "xxxx" });
 
    // Function Call
    countLessThan(arr1, arr2);
  }
}
 
// This code is contributed by jithin.

Python3




# Python3 program for the above approach
from bisect import bisect_right as upper_bound
 
# Function to count the frequency
# of minimum character
def countMinFreq(s):
 
    # Sort the string s
    s = sorted(s)
 
    # Return the count with smallest
    # character
    x = 0
    for i in s:
        if i == s[0]:
            x += 1
    return x
 
# Function to count number of frequency
# of smallest character of string arr1[]
# is less than the string in arr2[]
def countLessThan(arr1, arr2):
     
    # To store the frequency of smallest
    # character in each string of arr2
    freq = []
 
    # Traverse the arr2[]
    for s in arr2:
 
        # Count the frequency of smallest
        # character in string s
        f = countMinFreq(s)
 
        # Append the frequency to freq[]
        freq.append(f)
 
    # Sort the frequency array
    feq = sorted(freq)
 
    # Traverse the array arr1[]
    for s in arr1:
 
        # Count the frequency of smallest
        # character in string s
        f = countMinFreq(s);
 
        # find the element greater than f
        it = upper_bound(freq,f)
 
        # Find the count such that
        # arr1[i] < arr2[j]
        cnt = len(freq)-it
 
        # Print the count
        print(cnt, end = " ")
 
# Driver Code
if __name__ == '__main__':
 
    arr1 = ["yyy", "zz"]
    arr2 = [ "x", "xx", "xxx", "xxxx"]
 
    # Function Call
    countLessThan(arr1, arr2);
 
# This code is contributed by Mohit Kumar

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG {
 
  // Function to count the frequency of
  // minimum character
  static int countMinFreq(String s)
  {
 
    // Sort the string s
    char[] tempArray = s.ToCharArray();
    Array.Sort(tempArray);
    s = new string(tempArray);
 
    // Return the count with smallest
    // character
    int x = 0;
    for (int i = 0; i < s.Length; i++)
      if (s[i] == s[0])
        x++;
    return x;
  }
 
  // Function to count number of frequency
  // of smallest character of string arr1[]
  // is less than the string in arr2[]
  static void countLessThan(List<string> arr1,
                            List<string> arr2)
  {
 
    // To store the frequency of smallest
    // character in each string of arr2
    List<int> freq = new List<int>();
 
    // Traverse the arr2[]
    foreach(string s in arr2)
    {
 
      // Count the frequency of smallest
      // character in string s
      int f = countMinFreq(s);
 
      // Append the frequency to freq[]
      freq.Add(f);
    }
 
    // Sort the frequency array
    freq.Sort();
 
    // Traverse the array arr1[]
    foreach(string s in arr1)
    {
 
      // Count the frequency of smallest
      // character in string s
      int f = countMinFreq(s);
 
      // find the element greater than f
      int it = upper_bound(freq, f);
 
      // Find the count such that
      // arr1[i] < arr2[j]
      int cnt = freq.Count - it;
 
      // Print the count
      Console.Write(cnt + " ");
    }
  }
 
  static int upper_bound(List<int> freq, int f)
  {
    int low = 0, high = freq.Count - 1;
 
    while (low < high) {
      int mid = (low + high) / 2;
      if (freq[mid] > f)
        high = mid;
      else
        low = mid + 1;
    }
 
    return (freq[low] < f) ? low++ : low;
  }
 
  // Driver Code
  public static void Main(string[] args)
  {
    List<string> arr1 = new List<string>();
    List<string> arr2 = new List<string>();
    arr1.Add("yyy");
    arr1.Add("zz");
    arr2.Add("x");
    arr2.Add("xx");
    arr2.Add("xxx");
    arr2.Add("xxxx");
 
    // Function Call
    countLessThan(arr1, arr2);
  }
}
 
// This code is contributed by phasing17.

Javascript




<script>
 
// JS program for the above approach
function upper_bound(freq, f)
{
    let low = 0, high = freq.length - 1;
 
    while (low < high) {
        let mid = Math.floor((low + high) / 2);
        if (freq[mid] > f)
            high = mid;
          else
            low = mid + 1;
    }
 
    return (freq[low] < f) ? low++ : low;
}
// Function to count the frequency of
// minimum character
function countMinFreq(s)
{
 
    // Sort the string s
    s = s.split('').sort().join('');
    // Return the count with smallest
    // character
    let x = 0;
    for(let i=0;i<s.length;i++){
        if(s[i] == s[0])
            x += 1;
    }
    return x;
}
 
// Function to count number of frequency
// of smallest character of string arr1[]
// is less than the string in arr2[]
function countLessThan(arr1,arr2)
{
    // To store the frequency of smallest
    // character in each string of arr2
    let freq = [];
 
    // Traverse the arr2[]
    for (let i = 0;i< arr2.length;i++) {
 
        // Count the frequency of smallest
        // character in string s
        let f = countMinFreq(arr2[i]);
 
        // Append the frequency to freq[]
        freq.push(f);
    }
 
    // Sort the frequency array
    freq= freq.sort(function(a,b){return a-b});
    // Traverse the array arr1[]
    for (let i = 0;i< arr1.length;i++) {
 
        // Count the frequency of smallest
        // character in string s
        let f = countMinFreq(arr1[i]);
 
        // find the element greater than f
        let it = upper_bound(freq, f);
 
        // Find the count such that
        // arr1[i] < arr2[j]
        let cnt = freq.length
                  - (it);
 
        // Print the count
        document.write(cnt,' ');
    }
}
 
// Driver Code
let arr1, arr2;
arr1 = [ "yyy", "zz" ];
arr2 = [ "x", "xx", "xxx", "xxxx" ];
 
// Function Call
countLessThan(arr1, arr2);
 
</script>

Output: 

1 2

 

Time Complexity: O(N + M*log M), where N and M are the lengths of given arrays respectively.

Auxiliary Space: O(M)
 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!