使用 M 的数字的 N 的最大计数，使得 2 和 5，以及，6 和 9 可以分别被视为相同

给定一个整数N和字符串整数M ，任务是通过使用字符串M的数字找到N的总数。此外，数字2可以被视为数字5 ，数字6可以被视为数字9 ，反之亦然，并且字符串M 中的每个数字最多只能使用一次。

例子：

Input: N = 6, M = “245769”
Output: 2
Explanation: Digits 5 and 6 are used to form the number 56. iop[The digits 2 and 9 are used to form the number 56. As 2 is treated as 5 and 9 is treated as 6.

Input: N = 25, M = “55”
Output: 1

方法：给定的问题可以通过Hashing解决。请按照以下步骤解决问题：

• 创建一个空的哈希图，比如map来存储给定字符串M的数字频率。
• 创建一个变量，比如len来存储字符串的长度。
• 使用变量i遍历给定的字符串S并迭代，直到i的值小于len并执行以下步骤：
  • 如果字符S[i]等于‘5’ ，则将其更改为‘2’ 。
  • 如果字符S[i]等于‘9’ ，则将其更改为‘6’。
  • 如果字符存在于mymap 中，则将频率更改为mymap.put(x, map.get(x)+1)。
  • 否则，将频率为 1 的字符作为mymap.put(x, 1)插入到地图中。
  • 将频率添加到地图后，增加i并继续下一次迭代。
• 创建一个空的哈希图，比如rems来存储数字N的数字。
• 迭代直到N的值大于0，执行以下步骤：
  • 创建一个变量，例如rem以使用模数运算符作为N%10存储N的最后一位数字。
  • 如果rem等于5 ，则将其更改为2 。
  • 如果rem等于9 ，则将其更改为6 。
  • 如果rem存在于rems映射中，则将频率增加 1 as rems.put(rem, rems.get(rem)+1) 。
  • 否则，将其作为rems.put(rem, 1)插入到rems映射中。
  • 将N除以 10。
• 创建一个变量，比如cnt来存储可以使用字符串M的给定数字形成的数字N的最大计数。
• 遍历地图rems ，并执行以下步骤：
  • 让地图中的每个对象都是ele。
  • 检查来自ele的键是否存在于字符串mymap的频率图中。
  • 如果不存在，则返回 0（如果字符串M 中不存在来自 N 的数字，则无法形成数字 N）。
  • 通过将mymap 中键的频率除以 rems映射中的频率来计算计数，即mymap.get(key)/ele.getValue() 。
  • 更新cnt 中所有迭代的最小值。
• 完成以上步骤后，打印cnt的值作为结果。

下面是上述方法的实现：

Java

// Java program for the above approach
 
import java.util.HashMap;
import java.util.Map;
 
public class GFG {
 
    // Function to find the count of
    // numbers that can be formed using
    // the given digits in the string
    int solve(int n, String str)
    {
 
        // Store the frequency of digits
        // from  the given string M
        HashMap mymap
            = new HashMap<>();
 
        // Store length of the string M
        int len = str.length();
 
        // Loop to traverse the string
        for (int i = 0; i < len; i++) {
            char c = str.charAt(i);
 
            // Replace 5 with 2
            if (c == '5')
                c = '2';
 
            // Replace 9 with 6
            else if (c == '9')
                c = '6';
 
            // Get the int form of
            // the current character
            // in the string
            int c_int = Integer.parseInt(
                String.valueOf(c));
 
            // Insert in the map
            if (mymap.containsKey(c_int))
                mymap.put(
                    c_int, mymap.get(c_int) + 1);
            else
                mymap.put(c_int, 1);
        }
 
        // Store all the digits of the
        // required number N
        HashMap rems
            = new HashMap<>();
 
        // Loop to get all the digits
        // from the number N
        while (n > 0) {
 
            // Get the last digit as
            // the remainder
            int rem = n % 10;
 
            // Replace 5 with 2
            if (rem == 5)
                rem = 2;
            // Replace 9 with 6
            if (rem == 9)
                rem = 6;
 
            // Insert the remainders
            // in the rems map
            if (rems.containsKey(rem))
                rems.put(rem, rems.get(rem) + 1);
            else
                rems.put(rem, 1);
 
            n = n / 10;
        }
 
        // Store the resultant count
        int cnt = Integer.MAX_VALUE;
 
        // Iterate through the rems map
        for (Map.Entry ele : rems.entrySet()) {
 
            // Get the key which is
            // a digit from the number
            // N to be formed
            int key = ele.getKey();
 
            // If not present in the
            // string M, number N that
            // cannot be formed
            if (!mymap.containsKey(key))
                return 0;
 
            // Divide the frequency of
            // the digit from the string
            // M with the frequency of
            // the current remainder
            int temp = mymap.get(key)
                       / ele.getValue();
 
            // Choose the minimum
            cnt = Math.min(cnt, temp);
        }
 
        // Return the maximum count
        return cnt;
    }
 
    // Driver Code
    public static void main(String args[])
    {
 
        GFG obj = new GFG();
        int N = 56;
        String M = "245769";
        System.out.println(obj.solve(N, M));
    }
}

Javascript

// Javascript program for the above approach
 
// Function to find the count of
// numbers that can be formed using
// the given digits in the string
function solve(n, str) {
  // Store the frequency of digits
  // from  the given string M
  let mymap = new Map();
 
  // Store length of the string M
  let len = str.length;
 
  // Loop to traverse the string
  for (let i = 0; i < len; i++) {
    let c = str.charAt(i);
 
    // Replace 5 with 2
    if (c == "5") c = "2";
    // Replace 9 with 6
    else if (c == "9") c = "6";
 
    // Get the int form of
    // the current character
    // in the string
    let c_int = parseInt(c);
 
    // Insert in the map
    if (mymap.has(c_int)) mymap.set(c_int, mymap.get(c_int) + 1);
    else mymap.set(c_int, 1);
  }
 
  // Store all the digits of the
  // required number N
  let rems = new Map();
 
  // Loop to get all the digits
  // from the number N
  while (n > 0) {
    // Get the last digit as
    // the remainder
    let rem = n % 10;
 
    // Replace 5 with 2
    if (rem == 5) rem = 2;
    // Replace 9 with 6
    if (rem == 9) rem = 6;
 
    // Insert the remainders
    // in the rems map
    if (rems.has(rem)) rems.set(rem, rems.get(rem) + 1);
    else rems.set(rem, 1);
 
    n = Math.floor(n / 10);
  }
 
  // Store the resultant count
  let cnt = Number.MAX_SAFE_INTEGER;
 
  // Iterate through the rems map
  for (let ele of rems) {
    // Get the key which is
    // a digit from the number
    // N to be formed
    let key = ele[0];
 
    // If not present in the
    // string M, number N that
    // cannot be formed
    if (!mymap.has(key)) return 0;
 
    // Divide the frequency of
    // the digit from the string
    // M with the frequency of
    // the current remainder
    let temp = mymap.get(key) / ele[1];
 
    // Choose the minimum
    cnt = Math.min(cnt, temp);
  }
 
  // Return the maximum count
  return cnt;
}
 
// Driver Code
 
let N = 56;
let M = "245769";
document.write(solve(N, M));
 
// This code is contributed by gfgking.

输出：

2

时间复杂度： O(N)
辅助空间： O(1)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。