Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Count of strings in the first array which are smaller than every string in the second array

  • Last Updated : 03 Jun, 2021

Given two arrays A[] and B[] which consists of N and M strings respectively. A string S1 is said to be smaller than string S2 if the frequency of the smallest character in the S1 is smaller than the frequency of the smallest character in S2. The task is to count the number of strings in A[] which are smaller than B[i] for every i.

Examples: 

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.

Input: A[] = {“aaa”, “aa”, “bdc”}, B[] = {“cccch”, “cccd”} 
Output: 3 2 
“cccch” has frequency of the smallest character as 4, and all the strings 
in A[] have frequencies of the smallest characters less than 4. 
“cccd” has frequency of the smallest character as 3 and only “aa” and “bdc” 
have frequencies of the smallest character less than 3.



Input: A[] = {“abca”, “jji”}, B[] = {“jhgkki”, “aaaa”, “geeks”} 
Output: 0 2 1 
  

A naive approach is to take every string in B[] and then count the number of strings in A[] which will satisfy the condition.
An efficient approach is to solve it using Binary Search and some pre-calculations as mentioned below: 

  • Initially count the frequency of the smallest character of every string and store in the vector/array.
  • Sort the vector/array in ascending order.
  • Now for every string in B[i], find the frequency of the smallest character.
  • Using lower_bound function in C++, or by doing a binary search in the vector/array, find the count of numbers which has frequency smaller than the frequency of the smallest character for every B[i].

Below is the implementation of the above approach:  

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
#define MAX 26
// Function to count the number of smaller
// strings in A[] for every string in B[]
vector<int> findCount(string a[], string b[], int n, int m)
{
 
    // Count the frequency of all characters
    int freq[MAX] = { 0 };
 
    vector<int> smallestFreq;
 
    // Iterate for all possible strings in A[]
    for (int i = 0; i < n; i++) {
        string s = a[i];
        memset(freq, 0, sizeof freq);
 
        // Increase the frequency of every character
        for (int j = 0; j < s.size(); j++) {
            freq[s[j] - 'a']++;
        }
 
        // Check for the smallest character's frequency
        for (int j = 0; j < MAX; j++) {
 
            // Get the smallest character frequency
            if (freq[j]) {
 
                // Insert it in the vector
                smallestFreq.push_back(freq[j]);
                break;
            }
        }
    }
 
    // Sort the count of all the frequency of the smallest
    // character in every string
    sort(smallestFreq.begin(), smallestFreq.end());
 
    vector<int> ans;
 
    // Iterate for every string in B[]
    for (int i = 0; i < m; i++) {
        string s = b[i];
 
        // Hash set every frequency 0
        memset(freq, 0, sizeof freq);
 
        // Count the frequency of every character
        for (int j = 0; j < s.size(); j++) {
            freq[s[j] - 'a']++;
        }
 
        int frequency = 0;
 
        // Find the frequency of the smallest character
        for (int j = 0; j < MAX; j++) {
            if (freq[j]) {
                frequency = freq[j];
                break;
            }
        }
 
        // Count the number of strings in A[]
        // which has the frequency of the smaller
        // character less than the frequency of the
        // smaller character of the string in B[]
        int ind = lower_bound(smallestFreq.begin(),
                              smallestFreq.end(), frequency)
                  - smallestFreq.begin();
 
        // Store the answer
        ans.push_back(ind);
    }
 
    return ans;
}
 
// Function to print the answer
void printAnswer(string a[], string b[], int n, int m)
{
 
    // Get the answer
    vector<int> ans = findCount(a, b, n, m);
 
    // Print the number of strings
    // for every answer
    for (auto it : ans) {
        cout << it << " ";
    }
}
 
// Driver code
int main()
{
    string A[] = { "aaa", "aa", "bdc" };
    string B[] = { "cccch", "cccd" };
    int n = sizeof(A) / sizeof(A[0]);
    int m = sizeof(B) / sizeof(B[0]);
 
    printAnswer(A, B, n, m);
 
    return 0;
}
Java



// Java implementation of the approach
import java.util.*;
class GFG
{
    static int MAX = 26;
     
    // Function to count the number of smaller
    // strings in A[] for every String in B[]
    static Vector<Integer> findCount(String a[],
                                     String b[],
                                     int n, int m)
    {
     
        // Count the frequency of all characters
        int []freq = new int[MAX];
     
        Vector<Integer> smallestFreq = new Vector<Integer>();
     
        // Iterate for all possible strings in A[]
        for (int i = 0; i < n; i++)
        {
            String s = a[i];
            Arrays.fill(freq, 0);
             
            // Increase the frequency of every character
            for (int j = 0; j < s.length(); j++)
            {
                freq[s.charAt(j) - 'a']++;
            }
     
            // Check for the smallest character's frequency
            for (int j = 0; j < MAX; j++)
            {
     
                // Get the smallest character frequency
                if (freq[j] > 0)
                {
     
                    // Insert it in the vector
                    smallestFreq.add(freq[j]);
                    break;
                }
            }
        }
     
        // Sort the count of all the frequency of
        // the smallest character in every string
        Collections.sort(smallestFreq);
     
        Vector<Integer> ans = new Vector<Integer>();
     
        // Iterate for every String in B[]
        for (int i = 0; i < m; i++)
        {
            String s = b[i];
     
            // Hash set every frequency 0
            Arrays.fill(freq, 0);
     
            // Count the frequency of every character
            for (int j = 0; j < s.length(); j++)
            {
                freq[s.charAt(j) - 'a']++;
            }
     
            int frequency = 0;
     
            // Find the frequency of the smallest character
            for (int j = 0; j < MAX; j++)
            {
                if (freq[j] > 0)
                {
                    frequency = freq[j];
                    break;
                }
            }
     
            // Count the number of strings in A[]
            // which has the frequency of the smaller
            // character less than the frequency of the
            // smaller character of the String in B[]
            int [] array = new int[smallestFreq.size()];
            int k = 0;
            for(Integer val:smallestFreq)
            {
                array[k] = val;
                k++;
            }
                 
            int ind = lower_bound(array, 0,
                                  smallestFreq.size(),
                                  frequency);
     
            // Store the answer
            ans.add(ind);
        }
        return ans;
    }
     
    static int lower_bound(int[] a, int low,
                           int high, int element)
    {
        while(low < high)
        {
            int middle = low + (high - low) / 2;
            if(element > a[middle])
                low = middle + 1;
            else
                high = middle;
        }
        return low;
    }
     
    // Function to print the answer
    static void printAnswer(String a[], String b[],
                            int n, int m)
    {
     
        // Get the answer
        Vector<Integer> ans = findCount(a, b, n, m);
     
        // Print the number of strings
        // for every answer
        for (Integer it : ans)
        {
            System.out.print(it + " ");
        }
    }
     
    // Driver code
    public static void main(String[] args)
    {
        String A[] = { "aaa", "aa", "bdc" };
        String B[] = { "cccch", "cccd" };
        int n = A.length;
        int m = B.length;
     
        printAnswer(A, B, n, m);
    }
}
 
// This code is contributed by 29AjayKumar
Python3



# Python3 implementation of the approach
from bisect import bisect_left as lower_bound
 
MAX = 26
 
# Function to count the number of smaller
# strings in A for every in B
def findCount(a, b, n, m):
 
    # Count the frequency of all characters
    freq=[0 for i in range(MAX)]
 
    smallestFreq=[]
 
    # Iterate for all possible strings in A
    for i in range(n):
        s = a[i]
 
        for i in range(MAX):
            freq[i]=0
 
        # Increase the frequency of every character
        for j in range(len(s)):
            freq[ord(s[j]) - ord('a')]+= 1
 
        # Check for the smallest character's frequency
        for j in range(MAX):
 
            # Get the smallest character frequency
            if (freq[j]):
 
                # Insert it in the vector
                smallestFreq.append(freq[j])
                break
 
 
    # Sort the count of all the frequency of the smallest
    # character in every string
    smallestFreq=sorted(smallestFreq)
 
    ans=[]
 
    # Iterate for every in B
    for i in range(m):
        s = b[i]
 
        # Hash set every frequency 0
        for i in range(MAX):
            freq[i]=0
 
        # Count the frequency of every character
        for j in range(len(s)):
            freq[ord(s[j]) - ord('a')]+= 1
 
 
        frequency = 0
 
        # Find the frequency of the smallest character
        for j in range(MAX):
            if (freq[j]):
                frequency = freq[j]
                break
 
        # Count the number of strings in A
        # which has the frequency of the smaller
        # character less than the frequency of the
        # smaller character of the in B
        ind = lower_bound(smallestFreq,frequency)
 
        # Store the answer
        ans.append(ind)
 
    return ans
 
 
# Function to print the answer
def printAnswer(a, b, n, m):
 
    # Get the answer
    ans = findCount(a, b, n, m)
 
    # Print the number of strings
    # for every answer
    for it in ans:
        print(it,end=" ")
 
# Driver code
 
A = ["aaa", "aa", "bdc"]
B = ["cccch", "cccd"]
n = len(A)
m = len(B)
 
printAnswer(A, B, n, m)
 
# This code is contributed by mohit kumar 29
C#



// C# implementation of the approach
using System;
using System.Collections.Generic;   
public class GFG
{
    static int MAX = 26;
      
    // Function to count the number of smaller
    // strings in A[] for every String in B[]
    static List<int> findCount(String []a,
                                     String []b,
                                     int n, int m)
    {
      
        // Count the frequency of all characters
        int []freq = new int[MAX];
      
        List<int> smallestFreq = new List<int>();
      
        // Iterate for all possible strings in A[]
        for (int i = 0; i < n; i++)
        {
            String s = a[i];
            for (int l = 0; l < freq.Length; l++)
                freq[l]=0;
              
            // Increase the frequency of every character
            for (int j = 0; j < s.Length; j++)
            {
                freq[s[j] - 'a']++;
            }
      
            // Check for the smallest character's frequency
            for (int j = 0; j < MAX; j++)
            {
      
                // Get the smallest character frequency
                if (freq[j] > 0)
                {
      
                    // Insert it in the vector
                    smallestFreq.Add(freq[j]);
                    break;
                }
            }
        }
      
        // Sort the count of all the frequency of
        // the smallest character in every string
        smallestFreq.Sort();
      
        List<int> ans = new List<int>();
      
        // Iterate for every String in B[]
        for (int i = 0; i < m; i++)
        {
            String s = b[i];
      
            // Hash set every frequency 0
            for (int l = 0; l < freq.Length; l++)
                freq[l]=0;
      
            // Count the frequency of every character
            for (int j = 0; j < s.Length; j++)
            {
                freq[s[j] - 'a']++;
            }
      
            int frequency = 0;
      
            // Find the frequency of the smallest character
            for (int j = 0; j < MAX; j++)
            {
                if (freq[j] > 0)
                {
                    frequency = freq[j];
                    break;
                }
            }
      
            // Count the number of strings in A[]
            // which has the frequency of the smaller
            // character less than the frequency of the
            // smaller character of the String in B[]
            int [] array = new int[smallestFreq.Count];
            int k = 0;
            foreach (int val in smallestFreq)
            {
                array[k] = val;
                k++;
            }
                  
            int ind = lower_bound(array, 0,
                                  smallestFreq.Count,
                                  frequency);
      
            // Store the answer
            ans.Add(ind);
        }
        return ans;
    }
      
    static int lower_bound(int[] a, int low,
                           int high, int element)
    {
        while(low < high)
        {
            int middle = low + (high - low) / 2;
            if(element > a[middle])
                low = middle + 1;
            else
                high = middle;
        }
        return low;
    }
      
    // Function to print the answer
    static void printAnswer(String []a, String []b,
                            int n, int m)
    {
      
        // Get the answer
        List<int> ans = findCount(a, b, n, m);
      
        // Print the number of strings
        // for every answer
        foreach (int it in ans)
        {
            Console.Write(it + " ");
        }
    }
      
    // Driver code
    public static void Main(String[] args)
    {
        String []A = { "aaa", "aa", "bdc" };
        String []B = { "cccch", "cccd" };
        int n = A.Length;
        int m = B.Length;
      
        printAnswer(A, B, n, m);
    }
}
// This code is contributed by Princi Singh
Javascript



<script>
 
// JavaScript implementation of the approach
const MAX = 26;
 
// Function to count the number of smaller
// strings in A[] for every String in B[]
function findCount(a, b, n, m)
{
    // Count the frequency of all characters
    var freq = new Array(MAX).fill(0);
     
    var smallestFreq = [];
     
    // Iterate for all possible strings in A[]
    for(var i = 0; i < n; i++)
    {
        var s = a[i];
        for(var l = 0; l < freq.length; l++)
            freq[l] = 0;
         
        // Increase the frequency of every character
        for(var j = 0; j < s.length; j++)
        {
            freq[s[j].charCodeAt(0) -
                  "a".charCodeAt(0)]++;
        }
         
        // Check for the smallest character's frequency
        for(var j = 0; j < MAX; j++)
        {
             
            // Get the smallest character frequency
            if (freq[j] > 0)
            {
                 
                // Insert it in the vector
                smallestFreq.push(freq[j]);
                break;
            }
        }
    }
     
    // Sort the count of all the frequency of
    // the smallest character in every string
    smallestFreq.sort();
     
    var ans = [];
     
    // Iterate for every String in B[]
    for(var i = 0; i < m; i++)
    {
        var s = b[i];
         
        // Hash set every frequency 0
        for(var l = 0; l < freq.length; l++)
            freq[l] = 0;
         
        // Count the frequency of every character
        for(var j = 0; j < s.length; j++)
        {
            freq[s[j].charCodeAt(0) -
                  "a".charCodeAt(0)]++;
        }
         
        var frequency = 0;
         
        // Find the frequency of the smallest character
        for(var j = 0; j < MAX; j++)
        {
            if (freq[j] > 0)
            {
                frequency = freq[j];
                break;
            }
        }
     
        // Count the number of strings in A[]
        // which has the frequency of the smaller
        // character less than the frequency of the
        // smaller character of the String in B[]
        var array = new Array(smallestFreq.length).fill(0);
        var k = 0;
         
        for(const val of smallestFreq)
        {
            array[k] = val;
            k++;
        }
         
        var ind = lower_bound(
            array, 0, smallestFreq.length, frequency);
         
        // Store the answer
        ans.push(ind);
    }
    return ans;
}
 
function lower_bound(a, low, high, element)
{
    while (low < high)
    {
        var middle = low + parseInt((high - low) / 2);
        if (element > a[middle])
            low = middle + 1;
        else
            high = middle;
    }
    return low;
}
 
// Function to print the answer
function printAnswer(a, b, n, m)
{
    // Get the answer
    var ans = findCount(a, b, n, m);
     
    // Print the number of strings
    // for every answer
    for(const it of ans)
    {
        document.write(it + " ");
    }
}
 
// Driver code
var A = [ "aaa", "aa", "bdc" ];
var B = [ "cccch", "cccd" ];
var n = A.length;
var m = B.length;
 
printAnswer(A, B, n, m);
 
// This code is contributed by rdtank
 
</script>
Output: 
3 2
 



My Personal Notes
arrow_drop_up
Previous
| | Question
Next

| | Question
Recommended Articles
Page :
Check if a triplet of buildings can be selected such that the third building is taller than the first building and smaller than the second building
25, May 21
Count number of rotated strings which have more number of vowels in the first half than second half
23, Oct 19
Delete array elements which are smaller than next or become smaller
22, Mar 18
Probability of obtaining pairs from two arrays such that element from the first array is smaller than that of the second array
14, Jun 21
Count subsequences in first string which are anagrams of the second string
28, Dec 17
Find the element before which all the elements are smaller than it, and after which all are greater
24, Oct 15
Remove characters from the first string which are present in the second string
23, May 09
Most frequent word in first String which is not present in second String
13, Nov 18
Count nodes from all lower levels smaller than minimum valued node of current level for every level in a Binary Tree
14, Sep 20
Count of array elements which is smaller than both its adjacent elements
22, May 20
Count of elements in first Array greater than second Array with each element considered only once
07, May 20
Count elements in first Array with absolute difference greater than K with an element in second Array
05, May 20
Largest element smaller than current element on left for every element in Array
30, Mar 20
Given two strings, find if first string is a subsequence of second
12, Oct 14
Count of times second string can be formed from the characters of first string
18, Dec 19
Rearrange the Array to maximize the elements which is smaller than both its adjacent elements
24, Jun 21
Check if all K-length subset sums of first array greater than that of the second array
10, Dec 20
Check if mapping is possible to make sum of first array larger than second array
17, Jun 21
Number of indices pair such that element pair sum from first Array is greater than second Array
25, Mar 20
Length of longest subarray in which elements greater than K are more than elements not greater than K
14, Aug 19
Longest subarray in which all elements are smaller than K
02, Dec 20
Check if any anagram of string S is lexicographically smaller than that of string T
25, Nov 21
Find elements which are present in first array and not in second
29, Jan 17
Frequency of smallest character in first sentence less than that of second sentence
30, Apr 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Striver
@Striver
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

Start Your Coding Journey Now!