根据数字乘积分组时最大组的计数

给定一个整数 N ，任务是找到具有最大大小的组的数量。从 1 到 N 的每个数字都根据其数字的乘积分组。
例子：

Input: N = 13 
Output: 3 
Explanation: 
There are 9 groups in total, they are grouped according to the product of its digits 
of numbers from 1 to 13: [1, 11] [2, 12] [3, 13] [4] [5] [6] [7] [8] [9]. 
Out of these, 3 groups have the largest size that is 2.
Input: N = 2 
Output: 2 
Explanation: 
There are 2 groups in total, they are grouped according to the product of its digits 
of numbers from 1 to 2: [1] [2]. 
Out of these, 2 groups have the largest size that is 1. 
 

方法：
为了解决上面提到的问题，我们必须使用哈希映射存储从 1 到 N 的每个元素的数字的乘积，如果重复则增加其频率。然后我们必须在哈希图中找到最大频率，这将是组的最大大小。最后，统计与最大组数相同频率的所有组数并返回计数。
下面是上述方法的实现：

C++

// C++ implementation to Count the
// groups having largest size while
// grouping is according to
// the product of its digits
#include 
using namespace std;
 
// Function to find out product of digit
int digit_prod(int x)
{
    int prod = 1;
 
    // calculate product
    while (x) {
        prod *= x % 10;
        x = x / 10;
    }
 
    // return the product of digits
    return prod;
}
 
// Function to find the count
int find_count(int n)
{
 
    // hash map for
    // counting frequency
    map mpp;
 
    for (int i = 1; i <= n; i++) {
        // counting freq of each element
        mpp[digit_prod(i)] += 1;
    }
 
    int ans = 1;
    int maxm = 0;
    for (auto x : mpp) {
 
        // find the maximum
        if (x.second > maxm) {
            maxm = x.second;
            ans = 1;
        }
 
        else if (x.second == maxm) {
            // count the number of groups having
            // size of equal to largest group.
            ans++;
        }
    }
 
    return ans;
}
 
// Driver code
int main()
{
 
    // initialise N
    int N = 13;
 
    cout << find_count(N);
 
    return 0;
}

Java

// Java implementation to Count the
// groups having largest size while
// grouping is according to
// the product of its digits
import java.io.*;
import java.util.*;
 
class GFG{
 
// Function to find out product of digit
static int digit_prod(int x)
{
    int prod = 1;
 
    // Calculate product
    while (x != 0)
    {
        prod *= x % 10;
        x = x / 10;
    }
 
    // Return the product of digits
    return prod;
}
 
// Function to find the count
static int find_count(int n)
{
     
    // Hash map for counting frequency
    Map mpp = new HashMap<>();
 
    for(int i = 1; i <= n; i++)
    {
         
        // Counting freq of each element
        int t = digit_prod(i);
        mpp.put(t, mpp.getOrDefault(t, 0) + 1);
    }
 
    int ans = 1;
    int maxm = 0;
     
    for(Integer x : mpp.values())
    {
         
        // Find the maximum
        if (x > maxm)
        {
            maxm = x;
            ans = 1;
        }
 
        else if (x == maxm)
        {
             
            // Count the number of groups having
            // size of equal to largest group.
            ans++;
        }
    }
    return ans;
}
 
// Driver Code
public static void main(String args[])
{
     
    // Initialise N
    int N = 13;
 
    System.out.print(find_count(N));
}
}
 
// This code is contributed by offbeat

Python3

# Python3 implementation to Count the
# groups having largest size while
# grouping is according to
# the product of its digits
 
# Function to find out product of digit
def digit_prod(x) :
    prod = 1
 
    # calculate product
    while(x) :
        prod = prod * (x % 10)
        x = x // 10
     
    # return the product of digits
    return prod
 
# Function to find the count
def find_count(n) :
     
    # hash map for
    # counting frequency
    mpp = {}
 
    for i in range(1, n + 1):
         
        # counting freq of each element
        x = digit_prod(i)
 
        if x in mpp :
            mpp[x] += 1
        else :
            mpp[x] = 1
 
    ans = 1
    maxm = 0
 
    for value in mpp.values() :
 
        # find the maximum
        if (value > maxm) :
            maxm = value
            ans = 1
        elif (value == maxm) :
             
            # count the number of groups having
            # size of equal to largest group.
            ans = ans + 1
 
    return ans
 
# Driver code
 
# initialise N
N = 13
 
print(find_count(N))
 
# This code is contributed by Sanjit_Prasad

C#

// C# implementation to count the
// groups having largest size while
// grouping is according to
// the product of its digits
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
 
class GFG{
     
// Function to find out product of digit
static int digit_prod(int x)
{
    int prod = 1;
 
    // Calculate product
    while (x != 0)
    {
        prod *= x % 10;
        x = x / 10;
    }
 
    // Return the product of digits
    return prod;
}
 
// Function to find the count
static int find_count(int n)
{
     
    // Hash map for counting frequency
    Dictionary mpp = new Dictionary();
 
    for(int i = 1; i <= n; i++)
    {
         
        // Counting freq of each element
        int t = digit_prod(i);
        if (mpp.ContainsKey(t))
        {
            mpp[t]++;
        }
        else
        {
            mpp[i] = 1;
        }
    }
 
    int ans = 1;
    int maxm = 0;
     
    foreach(KeyValuePair x in mpp)
    {
         
        // Find the maximum
        if (x.Value > maxm)
        {
            maxm = x.Value;
            ans = 1;
        }
        else if (x.Value == maxm)
        {
             
            // Count the number of groups having
            // size of equal to largest group.
            ans++;
        }
    }
    return ans;
}
     
// Driver Code
public static void Main(string[] args)
{
     
    // Initialise N
    int N = 13;
 
    Console.Write(find_count(N));
}
}
 
// This code is contributed by rutvik_56

Javascript

 
// JavaScript implementation to Count the
// groups having largest size while
// grouping is according to
// the product of its digits
 
 
// Function to find out product of digit
function digit_prod(x) {
    let prod = 1;
 
    // calculate product
    while (x != 0) {
        prod = prod * (x % 10);
        x = Math.floor(x / 10);
    }
 
    // return the product of digits
    return prod;
}
 
// Function to find the count
function find_count(n) {
 
    // hash map for
    // counting frequency
    let mpp = new Map();
 
    for (let i = 1; i <= n; i++) {
        // counting freq of each element
        let t = digit_prod(i)
 
        if (mpp.has(t)) {
            mpp.set(t, mpp.get(t) + 1)
        } else {
            mpp.set(t, 1)
        }
    }
 
    let ans = 1;
    let maxm = 0;
    for (let x of mpp) {
 
        // find the maximum
        if (x[1] > maxm) {
            maxm = x[1];
            ans = 1;
        }
 
        else if (x[1] == maxm) {
            // count the number of groups having
            // size of equal to largest group.
            ans++;
        }
    }
 
    return ans;
}
 
// Driver code
 
// initialise N
let N = 13;
 
document.write(find_count(N));
 
// This code is contributed by _saurabh_jaiswal
 

输出：

3

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