Open In App

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

Improve
Improve
Like Article
Like
Save
Share
Report

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


C#




// Include namespace system
using System;
using System.Collections.Generic;
 
public class GFG
{
 
  // Function to find the factors
  // of K in N
  public static List<int> findFactors(int n, int k)
  {
    var factors = new List<int>();
 
    // 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 ((int)(k / i) == i && i <= n)
        {
          factors.Add(i);
        }
        else
        {
          if (i <= n)
          {
            factors.Add(i);
          }
          if ((int)(k / i) <= n)
          {
            factors.Add((int)(k / i));
          }
        }
      }
    }
    return factors;
  }
 
  // Find the digit sum of each factor
  public static List<int> findDigitSum(List<int> a)
  {
 
    // Sum of digits for each
    // element in vector
    for (int i = 0; i < a.Count; i++)
    {
      var c = 0;
      while (a[i] > 0)
      {
        c += (a[i] % 10);
        a[i] = ((int)(a[i] / 10));
      }
      a[i] = c;
    }
    return a;
  }
 
  // Find the largest M distinct digit
  // sum from the digitSum vector
  public static int findMMaxDistinctDigitSum(List<int> distinctDigitSum, int m)
  {
 
    // Find the sum of last M numbers.
    var sum = 0;
    for (int i = distinctDigitSum.Count - 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.
  public static int findDistinctMnumbers(int n, int k, int m)
  {
 
    // Find out the factors of
    // K less than N
    var factors = GFG.findFactors(n, k);
 
    // Sum of digits for each
    // element in vector
    var digitSum = GFG.findDigitSum(factors);
 
    // Sorting the digitSum vector
    digitSum.Sort();
 
    // Removing the duplicate elements
    var hs1 = new HashSet<int>(digitSum);
 
    // "HashSet" is stores only unique elements
    var vect2 = new List<int>(hs1);
 
    // Finding the sum and returning it
    return GFG.findMMaxDistinctDigitSum(vect2, m);
  }
 
  // Driver Code
  public static void Main(String[] args)
  {
    var n = 100;
    var k = 80;
    var m = 4;
 
    // Function Call
    Console.WriteLine(GFG.findDistinctMnumbers(n, k, m));
  }
}
 
// This code is contributed by aadityaburujwale.


Javascript




<script>
 
// Javascript implementation to find the sum of
// maximum distinct digit sum of at most
// M numbers from 1 to N that are factors of K
 
// Function to find the factors
// of K in N
function findFactors(n, k)
{
    let factors = [];
     
    // Initialise a vector
  
    // Find out the factors of
    // K less than N
    for(let i = 1; i <= Math.sqrt(k); i++)
    {
        if (k % i == 0)
        {
            if (k / i == i && i <= n)
                factors.push(i);
            else
            {
                if (i <= n)
                    factors.push(i);
                if (k / i <= n)
                    factors.push(k / i);
            }
        }
    }
    return factors;
}
 
// Find the digit sum of each factor
function findDigitSum(a)
{
     
    // Sum of digits for each
    // element in vector
    for(let i = 0; i < a.length; i++)
    {
        let c = 0;
         
        while (a[i] > 0)
        {
            c += (a[i] % 10);
            a[i] = Math.floor(a[i] / 10);
        }
        a[i] = c;
    }
    return a;
}
 
// Find the largest M distinct digit
// sum from the digitSum vector
function findMMaxDistinctDigitSum(distinctDigitSum, m)
{
     
    // Find the sum of last M numbers.
    let sum = 0;
    for(let i = distinctDigitSum.length - 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.
function findDistinctMnumbers(n, k, m)
{
     
    // Find out the factors of
    // K less than N
    let factors = findFactors(n, k);
  
    // Sum of digits for each
    // element in vector
    let digitSum = findDigitSum(factors);
  
    // Sorting the digitSum vector
    digitSum.sort(function(a, b){return a - b;});
  
    // Removing the duplicate elements
    let hs1 = new Set(digitSum);
  
    // "HashSet" is stores only unique elements
    let vect2 = Array.from(hs1);
  
    // Finding the sum and returning it
    return findMMaxDistinctDigitSum(vect2, m);
}
 
// Driver Code
let n = 100, k = 80, m = 4;
 
// Function Call
document.write(findDistinctMnumbers(n, k, m));
     
// This code is contributed by rag2127
 
</script>


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

 



Last Updated : 29 Nov, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads