Skip to content
Related Articles

Related Articles

Sum of M maximum distinct digit sum from 1 to N that are factors of K
  • Difficulty Level : Expert
  • Last Updated : 14 Jan, 2021

Given an array of natural numbers upto N and two numbers M and K, the task is to find the sum of M maximum distinct digit sum M numbers from N natural numbers which are factors of K.
Examples: 
 

Input: N = 50, M = 4, K = 30 
Output: 16 
Explanation: 
From 1 to 50, factors of 30 = {1, 2, 3, 5, 6, 10, 15, 30}. 
Digit sum of every factor = {1, 2, 3, 5, 6, 1, 6, 3}. 
4 largest digit sum = 2, 3, 5, 6. 
Sum = 16
Input: N = 5, M = 3, K = 74 
Output:
Explanation: 
From 1 to 5 factors of 74 = {1, 2} 
Digit sum of every factor = {1, 2}. 
3 largest digit sum = 1, 2 (Here only 2 such numbers are present. But it is asked for atmost M. So these 2 will be considered only.) 
Sum = 3 
 

 

Naive Approach: Simple solution is to run the loop from 1 to N and find the list of all numbers that perfectly divides K. Find the digit sum of each factor and sort them in descending order and print M distinct elements from this list from top.
Efficient Approach: 
 

  • Find all the factors of K in the range of 1 to N by iterating from 2 to √K such that the element completely divides the number. For Detailed Explanation of this approach please refer this article and store them in an array.
  • Find the digit sum of the numbers stored in the factors array. 
    For Example: 
     
For the Given Array - {4, 10, 273 }

Digit Sum of the Elements - 
Element 0 Digit Sum - "4" = 4
Element 1 Digit Sum - "10" = 1 + 0 = 10
Element 2 Digit Sum - "273" = 2 + 7 + 3 = 12
  •  
  • Remove duplicates from the digit sum as we need distinct elements.
  • Sort the distinct digit sums in reverse order and find the sum of first at most M elements out of this digit-sum array.

Below is the implementation of the above approach.
 



C++




// C++ implementation to find the sum of
// maximum distinct digit sum of at most
// M numbers from 1 to N that are factors of K
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the factors
// of K in N
vector<int> findFactors(int n, int k)
{
 
    // Initialise a vector
    vector<int> factors;
 
    // Find out the factors of
    // K less than N
    for (int i = 1; i <= sqrt(k); i++) {
        if (k % i == 0) {
            if (k / i == i && i <= n)
                factors.push_back(i);
            else {
                if (i <= n)
                    factors.push_back(i);
                if (k / i <= n)
                    factors.push_back(k / i);
            }
        }
    }
 
    return factors;
}
 
// Find the digit sum of each factor
vector<int> findDigitSum(vector<int> a)
{
 
    // Sum of digits for each
    // element in vector
    for (int i = 0; i < a.size(); i++) {
        int c = 0;
        while (a[i] > 0) {
 
            c += a[i] % 10;
            a[i] = a[i] / 10;
        }
        a[i] = c;
    }
 
    return a;
}
 
// Find the largest M distinct digit
// sum from the digitSum vector
int findMMaxDistinctDigitSum(
    vector<int> distinctDigitSum,
    int m)
{
    // Find the sum of last M numbers.
    int sum = 0;
    for (int i = distinctDigitSum.size() - 1;
         i >= 0 && m > 0;
         i--, m--)
        sum += distinctDigitSum[i];
 
    return sum;
}
 
// Find the at most M numbers from N natural
// numbers whose digit sum is distinct
// and those M numbers are factors of K.
int findDistinctMnumbers(int n, int k, int m)
{
 
    // Find out the factors of
    // K less than N
    vector<int> factors = findFactors(n, k);
 
    // Sum of digits for each
    // element in vector
    vector<int> digitSum = findDigitSum(factors);
 
    // Sorting the digitSum vector
    sort(digitSum.begin(), digitSum.end());
 
    // Removing the duplicate elements
    vector<int>::iterator ip;
    ip = unique(digitSum.begin(), digitSum.end());
 
    digitSum.resize(distance(
        digitSum.begin(),
        ip));
 
    // Finding the sum and returning it
    return findMMaxDistinctDigitSum(digitSum, m);
}
 
// Driver Code
int main()
{
    int n = 100, k = 80, m = 4;
 
    // Function Call
    cout
        << findDistinctMnumbers(n, k, m)
        << endl;
 
    return 0;
}

Java




// Java implementation to find the sum of
// maximum distinct digit sum of at most
// M numbers from 1 to N that are factors of K
import java.util.*;
 
class GFG
{
 
// Function to find the factors
// of K in N
public static Vector<Integer> findFactors(int n, int k)
{
 
    Vector<Integer> factors = new Vector<Integer>();
    // Initialise a vector
 
    // Find out the factors of
    // K less than N
    for (int i = 1; i <= Math.sqrt(k); i++)
    {
        if (k % i == 0)
        {
            if (k / i == i && i <= n)
                factors.add(i);
            else
            {
                if (i <= n)
                    factors.add(i);
                if (k / i <= n)
                    factors.add(k / i);
            }
        }
    }
 
    return factors;
}
 
// Find the digit sum of each factor
public static Vector<Integer> findDigitSum(Vector<Integer> a)
{
 
    // Sum of digits for each
    // element in vector
    for (int i = 0; i < a.size(); i++)
    {
        int c = 0;
        while (a.get(i) > 0)
        {
 
            c += (a.get(i) % 10);
            a.set(i,(a.get(i)/10));
        }
        a.set(i,c);
    }
 
    return a;
}
 
// Find the largest M distinct digit
// sum from the digitSum vector
public static int findMMaxDistinctDigitSum(Vector<Integer> distinctDigitSum,int m)
{
    // Find the sum of last M numbers.
    int sum = 0;
    for (int i = distinctDigitSum.size() - 1;
            i >= 0 && m > 0;i--, m--)
        sum += distinctDigitSum.get(i);
 
    return sum;
}
 
// Find the at most M numbers from N natural
// numbers whose digit sum is distinct
// and those M numbers are factors of K.
public static int findDistinctMnumbers(int n, int k, int m)
{
 
    // Find out the factors of
    // K less than N
    Vector<Integer> factors = findFactors(n, k);
 
    // Sum of digits for each
    // element in vector
    Vector<Integer> digitSum = findDigitSum(factors);
 
    // Sorting the digitSum vector
     
    Collections.sort(digitSum);
 
    // Removing the duplicate elements
 
    HashSet<Integer> hs1 = new HashSet<Integer>(digitSum);
 
    //"HashSet" is stores only unique elements
 
    Vector<Integer> vect2 = new Vector<Integer>(hs1);
 
    // Finding the sum and returning it
    return findMMaxDistinctDigitSum(vect2, m);
}
 
// Driver Code
public static void main(String args[])
{
    int n = 100, k = 80, m = 4;
 
    // Function Call
    System.out.println(findDistinctMnumbers(n, k, m));
}
}
 
// This code is contributed by SoumikMondal

Python3




# Python 3 implementation to find the sum of
# maximum distinct digit sum of at most
# M numbers from 1 to N that are factors of K
import math
 
# Function to find the factors
# of K in N
def findFactors(n, k):
 
    # Initialise a vector
    factors = []
 
    # Find out the factors of
    # K less than N
    sqt = (int)(math.sqrt(k))
    for i in range(1, sqt):
        if (k % i == 0):
            if (k // i == i and i <= n):
                factors.append(i)
            else:
                if (i <= n):
                    factors.append(i)
                if (k // i <= n):
                    factors.append(k // i)
    return factors
 
# Find the digit sum of each factor
def findDigitSum(a):
 
    # Sum of digits for each
    # element in vector
    for i in range(len(a)):
        c = 0
        while (a[i] > 0):
            c += a[i] % 10
            a[i] = a[i] // 10
        a[i] = c
    return a
 
# Find the largest M distinct digit
# sum from the digitSum vector
def findMMaxDistinctDigitSum(
        distinctDigitSum, m):
 
    # Find the sum of last M numbers.
    sum = 0
    i = len(distinctDigitSum) - 1
    while (i >= 0 and m > 0):
        sum += distinctDigitSum[i]
        i -= 1
        m -= 1
    return sum
 
# Find the at most M numbers from N natural
# numbers whose digit sum is distinct
# and those M numbers are factors of K
def findDistinctMnumbers(n, k, m):
 
    # Find out the factors of
    # K less than N
    factors = findFactors(n, k)
 
    # Sum of digits for each
    # element in vector
    digitSum = findDigitSum(factors)
 
    # Sorting the digitSum vector
    digitSum.sort()
 
    # Removing the duplicate elements
    ip = list(set(digitSum))
 
    # Finding the sum and returning it
    return findMMaxDistinctDigitSum(ip, m)
 
# Driver Code
if __name__ == "__main__":
 
    n = 100
    k = 80
    m = 4
 
    # Function Call
    print(findDistinctMnumbers(n, k, m))
 
    # This code is contributed by chitranayal
Output: 
24

 

Performance Analysis: 
 

  • Time Complexity: In the given approach, there are mainly two process which is as follows – 
    • Time Complexity to find the factors of a number is: O(√(K))
    • Time complexity to sort and store the unique elements: O(√(K)log(√(K)))
  • Auxiliary Space: In the given approach there is an extra array used to store the factors of the number K, which is: O(√(K))

 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :