📜  第一句中最小字符的频率小于第二句中的频率

📅  最后修改于: 2021-04-21 21:22:11             🧑  作者: Mango

给定两个字符串数组arr1 []arr2 [] ,任务是计算arr2 []中字符串的数量,该字符串的最小字符频率小于arr1 []中每个字符串的最小字符频率。
例子:

方法:此问题可以使用贪婪方法解决。步骤如下:

  1. 对于数组arr2 []中的每个字符串,计算最小字符的频率并将其存储在数组中(例如freq [] )。
  2. 对频率数组freq []进行排序。
  3. 现在,对于数组arr1 []中的每个字符串,计算字符串中最小字符的频率(例如X )。
  4. 对于每个X ,使用本文讨论的方法,使用Binary Search在freq []中查找大于X的元素数。

下面是上述方法的实现:

C++
// C++ program for the above approach
 
#include 
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& arr1,
                   vector& arr2)
{
    // To store the frequency of smallest
    // character in each string of arr2
    vector 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 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 arr1,
                            List arr2)
  {
 
    // To store the frequency of smallest
    // character in each string of arr2
    List freq = new ArrayList();
 
    // 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 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 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


输出:
1 2

时间复杂度: O(N + M * log M) ,其中N和M分别是给定数组的长度。