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 = 16Input: N = 5, M = 3, K = 74
Output: 3
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++ 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 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 |
# 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
|
// 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. |
<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> |
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))