Open In App

Max count of N using digits of M such that 2 and 5, and, 6 and 9 can be treated as same respectively

Improve
Improve
Like Article
Like
Save
Share
Report

Given an integer N, and the string integer M, the task is to find the total count to make N by using the digits of string M. Also, digit 2 can be treated as digit 5, and digit 6 can be treated as digit 9 and vice versa and each digit from the string M can be used at most once.

Examples:

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

Approach: The given problem can be solved by Hashing. Follow the steps below to solve the problem:

  • Create an empty hashmap, say map to store the frequency of the digits of the given string M.
  • Create a variable, say, len to store the length of the string.
  • Traverse the given string S using the variable i and Iterate until the value of i is less than len and perform the following steps:
    • If the character S[i] is equal to ‘5’, then change it to ‘2’.
    • If the character S[i] is equal to ‘9’, then change it to ‘6’.
    • If the character is present in the mymap, then change the frequency as mymap.put(x, map.get(x)+1).
    • Otherwise, insert the character in the map with frequency 1 as mymap.put(x, 1).
    • After adding the frequency to the map, increment i and continue to the next iteration.
  • Create an empty hashmap, say rems to store the digits of the number N.
  • Iterate until the value of N is greater than 0, and perform the following steps:
    • Create a variable, say rem to store the last digit of N by using the modulus operator as N%10.
    • If rem is equal to 5, then change it to 2.
    • If rem is equal to 9, then change it to 6.
    • If the rem is present in the rems map, then increase the frequency by 1as rems.put(rem, rems.get(rem)+1).
    • Otherwise, insert it to the rems map as rems.put(rem, 1).
    • Divide N by 10.
  • Create a variable, say cnt to store the maximum count of the number N that can be formed using the given digits of string M.
  • Traverse through the map rems, and perform the following steps:
    • Let each object in the map is ele.
    • Check if the key from ele is present in the frequency map of string mymap.
    • If not present, the return 0 (The number N cannot be formed if a digit from N is not present in string M).
    • Calculate the count by dividing the frequency of the key in mymap with the frequency in rems map as mymap.get(key)/ele.getValue().
    • Update the minimum value from all iterations in cnt
  • After completing the above steps, print the value of cnt as the result.

Below is the implementation of the above approach:

C++




// C++ code to implement the approach
#include <climits>
#include <cmath>
#include <iostream>
#include <map>
using namespace std;
 
// C++ 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
  map<int, int> mymap;
 
  // 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[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 = c - '0';
 
    // Insert in the map
    if (mymap.count(c_int))
      mymap[c_int] += 1;
    else
      mymap[c_int] = 1;
  }
 
  // Store all the digits of the required number N
  map<int, int> rems;
 
  // 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.count(rem))
      rems[rem] += 1;
    else
      rems[rem] = 1;
 
    n = floor(n / 10);
  }
 
  // Store the resultant count
  int cnt = INT_MAX;
 
  // Iterate through the rems map
  for (auto ele : rems) {
    // Get the key which is a digit from the number N to
    // be formed
    int key = ele.first;
 
    // If not present in the string M, number N that
    // cannot be formed
    if (!mymap.count(key))
      return 0;
 
    // Divide the frequency of the digit from the string
    // M with the frequency of the current remainder
    int temp = mymap[key] / ele.second;
 
    // Choose the minimum
    cnt = min(cnt, temp);
  }
 
  // Return the maximum count
  return cnt;
}
 
// Driver code
int main()
{
  int N = 56;
  string M = "245769";
  cout << solve(N, M) << endl;
  return 0;
}
 
// This code is contributed by phasing17


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<Integer, Integer> 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<Integer, Integer> 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<Integer, Integer> 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));
    }
}


Python3




# Python3 program for the above approach
 
# Function to find the count of
# numbers that can be formed using
# the given digits in the string
def solve(n, str):
    # Store the frequency of digits
    # from  the given string M
    mymap = dict()
 
    # Store length of the string M
    length = len(str)
 
    # Loop to traverse the string
    for i in range(length):
        c = str[i]
 
        # Replace 5 with 2
        if c == "5":
            c = "2"
        # Replace 9 with 6
        elif c == "9":
            c = "6"
 
        # Get the int form of
        # the current character
        # in the string
        c_int = int(c)
 
        # Insert in the map
        if c_int in mymap:
            mymap[c_int] += 1
        else:
            mymap[c_int] = 1
 
    # Store all the digits of the
    # required number N
    rems = dict()
 
    # Loop to get all the digits
    # from the number N
    while n > 0:
        # Get the last digit as
        # the remainder
        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 rem in rems:
            rems[rem] += 1
        else:
            rems[rem] = 1
 
        n = n // 10
 
    # Store the resultant count
    cnt = float('inf')
 
    # Iterate through the rems map
    for key, value in rems.items():
        # If not present in the
        # string M, number N that
        # cannot be formed
        if key not in mymap:
            return 0
 
        # Divide the frequency of
        # the digit from the string
        # M with the frequency of
        # the current remainder
        temp = mymap[key] / value
 
        # Choose the minimum
        cnt = min(cnt, temp)
 
    # Return the maximum count
    return int(cnt)
 
# Driver Code
 
N = 56
M = "245769"
print(solve(N, M))
 
 
# This code is contributed by phasing17.


C#




using System;
using System.Collections;
using System.Linq;
using System.Collections.Generic;
 
public class GFG{
 
    static public void Main (){
 
        GFG obj = new GFG();
        int N = 56;
        String M = "245769";
        Console.WriteLine(obj.solve(N, M));
    }
  
 public int solve(int N, String M)
{
 
    // Store the frequency of digits
    // from  the given string M
    Dictionary<int,int> mymap
        = new Dictionary<int,int>();
 
    // Store length of the string M
    int len = M.Length;
 
    // Loop to traverse the string
    var cArr = M.ToCharArray();
    for (int i = 0; i < len; i++)
    {
        char c = cArr[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 = int.Parse(c.ToString());
 
        // Insert in the map
        if (mymap.ContainsKey(c_int))
            mymap[c_int]=(mymap[c_int] + 1);
        else
            mymap.Add(c_int, 1);
    }
 
    // Store all the digits of the
    // required number N
    Dictionary<int,int> rems
        = new Dictionary<int,int>();
 
    // 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[rem]= rems[rem] + 1;
        else
            rems.Add(rem, 1);
 
        N = N / 10;
    }
 
    // Store the resultant count
    int cnt = int.MaxValue;
 
    // Iterate through the rems map
    foreach (var ele in rems) {
 
    // Get the key which is
    // a digit from the number
    // N to be formed
    int key = ele.Key;
 
    // 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 = (int)mymap[key]
               / (int)ele.Value;
 
    // Choose the minimum
    cnt = Math.Min(cnt, temp);
}
 
// Return the maximum count
return cnt;
    }
   
}
 
// This code is contributed by el_genius.


Javascript




<script>
// 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.
</script>


Output

2

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



Last Updated : 10 Feb, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads