# Sum of M maximum distinct digit sum from 1 to N that are factors of K

• Difficulty Level : Expert
• Last Updated : 02 Jun, 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 ``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 findFactors(``int` `n, ``int` `k)``{` `    ``Vector factors = ``new` `Vector();``    ``// 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 findDigitSum(Vector 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 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 factors = findFactors(n, k);` `    ``// Sum of digits for each``    ``// element in vector``    ``Vector digitSum = findDigitSum(factors);` `    ``// Sorting the digitSum vector``    ` `    ``Collections.sort(digitSum);` `    ``// Removing the duplicate elements` `    ``HashSet hs1 = ``new` `HashSet(digitSum);` `    ``//"HashSet" is stores only unique elements` `    ``Vector vect2 = ``new` `Vector(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`

## Javascript

 ``
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))

My Personal Notes arrow_drop_up