Count of largest sized groups while grouping according to product of digits

Given an integer N, the task is to find the number of groups having the largest size. Each number from 1 to N is grouped according to the product of its digits.
Examples:

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. 

Approach:
To solve the problem mentioned above we have to store the product of digit of every element from 1 to N using hash map and increment its frequency if it repeats. Then we have to find the maximum frequency within the hash map, which would be the largest size of the group. Finally, count all the groups who have the same frequency count as the largest group and return the count.
Below is the implementation of the above approach: 

C++

// C++ implementation to Count the
// groups having largest size while
// grouping is according to
// the product of its digits
#include <bits/stdc++.h>
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<int, int> 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<Integer, Integer> 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<int,
               int> mpp = new Dictionary<int,
                                         int>();

    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<int, int> 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

<script>

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

</script>

Output:

3

Time complexity: O(nlog(d)), where n is the value of N and d is the number of digits in the largest number in the range

Space complexity: O(n)