 GFG App
Open App Browser
Continue

# Largest K digit integer from given Array divisible by M

Given an array arr[] of size N and 2 integers K and M the task is to find the largest integer of K digits from the array arr[] which is divisible by M. Print -1 if it is impossible to find any such integer.

Note: The value of K is such that the found integer is always less than or equal to INT_MAX.

Examples:

Input: arr[] = {1, 2, 3, 4, 5, 6}, N=6, K=3, M=4
Output: 652
Explanation: The largest of 3 digits is formed by the digits 6, 5, 2 with their indices 1. 4, and 5.

Input: arr[] = {4, 5, 4}, N=3, K=3, M=50
Output: -1
Explanation :- There exists no integer from the array which is divisible by 50 as there is no 0.

Naive Approach: This can be done by finding all sub-sequences of size K and then checking the condition to find the largest one.
Time Complexity: O(2N)
Auxiliary Space: O(1)

Efficient Approach: The idea is to check every number in multiple of M in the array that if it is possible to form that number or not. If it is possible, then update the answer. Follow the steps below to solve the problem:

Below is the implementation of the above approach.

## C++14

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the largest integer` `// of K digits divisible by M` `void` `find(vector<``int``>& arr, ``int` `N, ``int` `K, ``int` `M)` `{`   `    ``// Base Case, as there is no sub-sequence` `    ``// of size greater than N is possible` `    ``if` `(K > N) {` `        ``cout << ``"-1\n"``;` `        ``return``;` `    ``}`   `    ``// Vector to store the frequency of each` `    ``// number from the array` `    ``vector<``int``> freq(10, 0);`   `    ``// Calculate the frequency of each from` `    ``// the array` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``freq[arr[i]]++;` `    ``}`   `    ``// Sort the array in ascending order` `    ``sort(arr.begin(), arr.end());`   `    ``// Variable to store the maximum number` `    ``// possible` `    ``int` `X = 0;`   `    ``// Traverse and store the largest K digits` `    ``for` `(``int` `i = N - 1; K > 0; i--) {` `        ``X = X * 10 + arr[i];` `        ``K--;` `    ``}`   `    ``// Base Case` `    ``if` `(X < M) {` `        ``cout << ``"-1\n"``;` `        ``return``;` `    ``}`   `    ``// Variable to store the answer` `    ``int` `answer = -1;`   `    ``// Traverse and check for each number` `    ``for` `(``int` `i = M; i <= X; i = i + M) {` `        ``int` `y = i;` `        ``vector<``int``> v(10, 0);`   `        ``// Calculate the frequency of each number` `        ``while` `(y > 0) {` `            ``v[y % 10]++;` `            ``y = y / 10;` `        ``}`   `        ``bool` `flag = ``true``;`   `        ``// If frequency of any digit in y is less than` `        ``// that in freq[], then it's not possible.` `        ``for` `(``int` `j = 0; j <= 9; j++) {` `            ``if` `(v[j] > freq[j]) {` `                ``flag = ``false``;` `                ``break``;` `            ``}` `        ``}`   `        ``if` `(flag)` `            ``answer = max(answer, i);` `    ``}`   `    ``// Print the answer` `    ``cout << answer << endl;` `}`   `// Driver Code` `int` `main()` `{`   `    ``vector<``int``> arr = { 1, 2, 3, 4, 5, 6 };` `    ``int` `N = 6, K = 3, M = 4;`   `    ``find(arr, N, K, M);`   `    ``return` `0;` `}`

## Java

 `// Java code for the above approach` `import` `java.io.*;` `import` `java.util.Arrays;;` `class` `GFG` `{` `  `  `    ``// Function to find the largest integer` `    ``// of K digits divisible by M` `    ``static` `void` `find(``int``[] arr, ``int` `N, ``int` `K, ``int` `M)` `    ``{`   `        ``// Base Case, as there is no sub-sequence` `        ``// of size greater than N is possible` `        ``if` `(K > N) {` `            ``System.out.println(``"-1\n"``);` `            ``return``;` `        ``}`   `        ``// Vector to store the frequency of each` `        ``// number from the array` `        ``int` `freq[] = ``new` `int``[``10``];`   `        ``// Calculate the frequency of each from` `        ``// the array` `        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``freq[arr[i]]++;` `        ``}`   `        ``// Sort the array in ascending order` `        ``Arrays.sort(arr);`   `        ``// Variable to store the maximum number` `        ``// possible` `        ``int` `X = ``0``;`   `        ``// Traverse and store the largest K digits` `        ``for` `(``int` `i = N - ``1``; K > ``0``; i--) {` `            ``X = X * ``10` `+ arr[i];` `            ``K--;` `        ``}`   `        ``// Base Case` `        ``if` `(X < M) {` `            ``System.out.println(``"-1"``);` `            ``return``;` `        ``}`   `        ``// Variable to store the answer` `        ``int` `answer = -``1``;`   `        ``// Traverse and check for each number` `        ``for` `(``int` `i = M; i <= X; i = i + M) {` `            ``int` `y = i;` `            ``int` `v[] = ``new` `int``[``10``];`   `            ``// Calculate the frequency of each number` `            ``while` `(y > ``0``) {` `                ``v[y % ``10``]++;` `                ``y = y / ``10``;` `            ``}`   `            ``boolean` `flag = ``true``;`   `            ``// If frequency of any digit in y is less than` `            ``// that in freq[], then it's not possible.` `            ``for` `(``int` `j = ``0``; j <= ``9``; j++) {` `                ``if` `(v[j] > freq[j]) {` `                    ``flag = ``false``;` `                    ``break``;` `                ``}` `            ``}`   `            ``if` `(flag)` `                ``answer = Math.max(answer, i);` `        ``}`   `        ``// Print the answer` `        ``System.out.println(answer);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int``[] arr = { ``1``, ``2``, ``3``, ``4``, ``5``, ``6` `};` `        ``int` `N = ``6``, K = ``3``, M = ``4``;`   `        ``find(arr, N, K, M);` `    ``}` `}`   `// This code is contributed by Potta Lokesh`

## Python3

 `# Python program for the above approach`   `# Function to find the largest integer` `# of K digits divisible by M` `def` `find(arr, N, K, M):`   `    ``# Base Case, as there is no sub-sequence` `    ``# of size greater than N is possible` `    ``if` `(K > N):` `        ``print``(``"-1"``)` `        ``return`   `    ``# Vector to store the frequency of each` `    ``# number from the array` `    ``freq ``=` `[``0``] ``*` `10`   `    ``# Calculate the frequency of each from` `    ``# the array` `    ``for` `i ``in` `range``(N):` `        ``freq[arr[i]] ``+``=` `1`   `    ``# Sort the array in ascending order` `    ``arr.sort()`   `    ``# Variable to store the maximum number` `    ``# possible` `    ``X ``=` `0`   `    ``# Traverse and store the largest K digits` `    ``for` `i ``in` `range``(N ``-` `1``, ``2``, ``-``1``):` `        ``X ``=` `X ``*` `10` `+` `arr[i]` `        ``K ``-``=` `1`   `    ``# Base Case` `    ``if` `(X < M):` `        ``print``(``"-1"``)` `        ``return`   `    ``# Variable to store the answer` `    ``answer ``=` `-``1`   `    ``# Traverse and check for each number` `    ``for` `i ``in` `range``(M, X ``+` `1``, M):` `        ``y ``=` `i` `        ``v ``=` `[``0``] ``*` `10`   `        ``# Calculate the frequency of each number` `        ``while` `(y > ``0``):` `            ``v[y ``%` `10``] ``+``=` `1` `            ``y ``=` `y ``/``/` `10`   `        ``flag ``=` `True`   `        ``# If frequency of any digit in y is less than` `        ``# that in freq[], then it's not possible.` `        ``for` `j ``in` `range``(``10``):` `            ``if` `(v[j] > freq[j]):` `                ``flag ``=` `False` `                ``break`   `        ``if` `(flag):` `            ``answer ``=` `max``(answer, i)`   `    ``# Print the answer` `    ``print``(answer)`     `# Driver Code` `arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``6``]` `N ``=` `6` `K ``=` `3` `M ``=` `4`   `find(arr, N, K, M)`   `# This code is contributed by gfgking.`

## C#

 `// C# code for the above approach` `using` `System;`   `public` `class` `GFG` `{`   `    ``// Function to find the largest integer` `    ``// of K digits divisible by M` `    ``static` `void` `find(``int``[] arr, ``int` `N, ``int` `K, ``int` `M)` `    ``{`   `        ``// Base Case, as there is no sub-sequence` `        ``// of size greater than N is possible` `        ``if` `(K > N) {` `            ``Console.WriteLine(``"-1\n"``);` `            ``return``;` `        ``}`   `        ``// Vector to store the frequency of each` `        ``// number from the array` `        ``int` `[]freq = ``new` `int``;`   `        ``// Calculate the frequency of each from` `        ``// the array` `        ``for` `(``int` `i = 0; i < N; i++) {` `            ``freq[arr[i]]++;` `        ``}`   `        ``// Sort the array in ascending order` `        ``Array.Sort(arr);`   `        ``// Variable to store the maximum number` `        ``// possible` `        ``int` `X = 0;`   `        ``// Traverse and store the largest K digits` `        ``for` `(``int` `i = N - 1; K > 0; i--) {` `            ``X = X * 10 + arr[i];` `            ``K--;` `        ``}`   `        ``// Base Case` `        ``if` `(X < M) {` `            ``Console.WriteLine(``"-1"``);` `            ``return``;` `        ``}`   `        ``// Variable to store the answer` `        ``int` `answer = -1;`   `        ``// Traverse and check for each number` `        ``for` `(``int` `i = M; i <= X; i = i + M) {` `            ``int` `y = i;` `            ``int` `[]v = ``new` `int``;`   `            ``// Calculate the frequency of each number` `            ``while` `(y > 0) {` `                ``v[y % 10]++;` `                ``y = y / 10;` `            ``}`   `            ``bool` `flag = ``true``;`   `            ``// If frequency of any digit in y is less than` `            ``// that in freq[], then it's not possible.` `            ``for` `(``int` `j = 0; j <= 9; j++) {` `                ``if` `(v[j] > freq[j]) {` `                    ``flag = ``false``;` `                    ``break``;` `                ``}` `            ``}`   `            ``if` `(flag)` `                ``answer = Math.Max(answer, i);` `        ``}`   `        ``// Print the answer` `        ``Console.WriteLine(answer);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``int``[] arr = { 1, 2, 3, 4, 5, 6 };` `        ``int` `N = 6, K = 3, M = 4;`   `        ``find(arr, N, K, M);` `    ``}` `}`   `// This code is contributed by AnkThon`

## Javascript

 ``

Output

`652`

Time Complexity: O(max(M, N))
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up