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 = 30Output:16Explanation:

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 = 16Input:N = 5, M = 3, K = 74Output:3Explanation:

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****.**