GFG App
Open App
Browser
Continue

Minimum difference between values in an array with factors 1 to M

Given an array of nums of length N and an integer M, the task is to find the minimum difference between two elements of nums such that the numbers coming between these two integers (including the selected numbers) have all factors 1, 2, 3, …, M. Return the minimum difference if it does not exist then return -1.

Examples:

Input: N = 5, M = 7, nums = [6, 4, 5, 3, 7]
Output: 3
Explanation: First number will be 4 and the second will be 7, so the numbers between 4 and 7 are: [4, 5, 7]
Factors of 4 –> (1, 2, 4)
Factors of 5 –> (1, 5)
Factors of 7 –> (1, 7)
So, it contains every number from 1, 2, 3, 4, 5, 6, 7(as M = 7)

Input: N = 4, M = 2, nums = [3, 7, 2, 9]
Output: 0
Explanation: First number will be 2 and Second number is also 2
Factors of 2 –> (1, 2)
So it contains 1, 2(as M = 2)

Input: N = 3, M = 4, nums = [1, 3, 7]
Output: -1

Approach: To solve the problem follow the below-given steps:

• Sort the given array in a non-decreasing array
• Find factors of every number present in the given array.
• Now we will use two pointer approach to solve the problem and we will keep track of factors in Hash Map factorFreq.
• Start from the 0th index for both the ith and jth pointer.
• Now while factorFreq size is less than M, we will keep incrementing the jth pointer.
• If the size of factorFreq is equal to M then compare the difference between the jth value and ith value and increment the ith value, make sure you don’t forget to update the factorFreq.
• Return the min value if exist.

Below is the implementation of the above approach:

C++

 `#include `   `using` `namespace` `std;`   `// Function to find the factors of a given integer` `vector<``int``> factorsOfNumber(``int` `n)` `{` `    ``vector<``int``> factors = { 1 };` `    ``if` `(n == 1)` `        ``return` `factors;` `    ``for` `(``int` `i = 2; i * i <= n; i++) {` `        ``if` `(n % i == 0) {` `            ``if` `(n / i == i) {` `                ``factors.push_back(i);` `            ``}` `            ``else` `{` `                ``factors.push_back(i);` `                ``factors.push_back(n / i);` `            ``}` `        ``}` `    ``}` `    ``factors.push_back(n);` `    ``return` `factors;` `}`   `// Function to find the minimum difference of two selected` `// integers` `int` `findMinDifference(``int` `nums[], ``int` `N, ``int` `M)` `{`   `    ``// Sorting given array` `    ``sort(nums, nums + N);`   `    ``// Factors will contain the` `    ``// factors of the given integers` `    ``// in nums array` `    ``vector<``int``> factors[N];` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``factors[i] = factorsOfNumber(nums[i]);` `    ``}`   `    ``// factorFreq will map the` `    ``// frequency of factors which is` `    ``// less than or equal to M` `    ``map<``int``, ``int``> factorFreq;` `    ``int` `i = 0;` `    ``int` `j = 0;`   `    ``// minDiff will contain our` `    ``// final answer` `    ``int` `minDiff = INT_MAX;`   `    ``// Using two pointer` `    ``while` `(i < N && j < N) {`   `        ``// If factorFreq size is equal` `        ``// to M, then we can increment` `        ``// the pointer i` `        ``if` `(factorFreq.size() == M) {`   `            ``// Updating minDiff` `            ``minDiff = min(minDiff, (nums[j - 1] - nums[i]));`   `            ``// Updating factorFreq` `            ``for` `(``int` `k = 0; k < factors[i].size(); k++) {` `                ``if` `(factors[i][k] <= M) {` `                    ``factorFreq[factors[i][k]]--;` `                    ``if` `(factorFreq[factors[i][k]] == 0)` `                        ``factorFreq.erase(factors[i][k]);` `                ``}` `            ``}` `            ``i++;` `        ``}`   `        ``// Otherwise we will increment` `        ``// the j pointer` `        ``else` `{`   `            ``// Updating factorFreq` `            ``for` `(``int` `k = 0; k < factors[j].size(); k++) {` `                ``if` `(factors[j][k] <= M) {` `                    ``factorFreq[factors[j][k]]++;` `                ``}` `            ``}` `            ``j++;` `        ``}` `    ``}`   `    ``// Checking if i

Java

 `// Java algorithm for the above approach`   `import` `java.util.*;`   `class` `GFG {`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `N = ``5``;` `        ``int` `M = ``7``;` `        ``int``[] nums = { ``6``, ``4``, ``5``, ``3``, ``7` `};` `        ``System.out.println(findMinDifference(nums, N, M));` `    ``}`   `    ``// Function to find the minimum` `    ``// Difference of two selected integers` `    ``public` `static` `int` `findMinDifference(``int``[] nums, ``int` `N,` `                                        ``int` `M)` `    ``{`   `        ``// Sorting given array` `        ``Arrays.sort(nums);`   `        ``// Factors will contain the` `        ``// factors of the given integers` `        ``// in nums array` `        ``List[] factors = ``new` `ArrayList[N];` `        ``for` `(``int` `i = ``0``; i < N; i++) {` `            ``factors[i] = factorsOfNumber(nums[i]);` `        ``}`   `        ``// factorFreq will map the` `        ``// frequency of factors which is` `        ``// less than or equal to M` `        ``Map factorFreq = ``new` `HashMap<>();` `        ``int` `i = ``0``;` `        ``int` `j = ``0``;`   `        ``// minDiff will contain our` `        ``// final answer` `        ``int` `minDiff = Integer.MAX_VALUE;`   `        ``// Using two pointer` `        ``while` `(i < N && j < N) {`   `            ``// If factorFreq size is equal` `            ``// to M, then we can increment` `            ``// the pointer i` `            ``if` `(factorFreq.size() == M) {`   `                ``// Updating minDiff` `                ``minDiff = Math.min(minDiff,` `                                   ``(nums[j - ``1``] - nums[i]));` `                ``// Updating factorFreq` `                ``for` `(``int` `k = ``0``; k < factors[i].size();` `                     ``k++) {` `                    ``if` `(factors[i].get(k) <= M) {` `                        ``factorFreq.put(` `                            ``factors[i].get(k),` `                            ``factorFreq.get(` `                                ``factors[i].get(k))` `                                ``- ``1``);` `                        ``if` `(factorFreq.get(` `                                ``factors[i].get(k))` `                            ``== ``0``)` `                            ``factorFreq.remove(` `                                ``factors[i].get(k));` `                    ``}` `                ``}` `                ``i++;` `            ``}`   `            ``// Otherwise we will increment` `            ``// the j pointer` `            ``else` `{`   `                ``// Updating factorFreq` `                ``for` `(``int` `k = ``0``; k < factors[j].size();` `                     ``k++) {` `                    ``if` `(factors[j].get(k) <= M) {` `                        ``factorFreq.put(` `                            ``factors[j].get(k),` `                            ``factorFreq.getOrDefault(` `                                ``factors[j].get(k), ``0``)` `                                ``+ ``1``);` `                    ``}` `                ``}`   `                ``j++;` `            ``}` `        ``}`   `        ``// Checking if i factorsOfNumber(``int` `n)` `    ``{` `        ``List fact = ``new` `ArrayList<>();` `        ``fact.add(``1``);` `        ``if` `(n == ``1``)` `            ``return` `fact;` `        ``for` `(``int` `i = ``2``; i * i <= n; i++) {` `            ``if` `(n % i == ``0``) {` `                ``if` `(n / i == i) {` `                    ``fact.add(i);` `                ``}` `                ``else` `{` `                    ``fact.add(i);` `                    ``fact.add(n / i);` `                ``}` `            ``}` `        ``}`   `        ``fact.add(n);` `        ``return` `fact;` `    ``}` `}`

Python3

 `# Python code implementation:`   `import` `math` `from` `collections ``import` `defaultdict`   `def` `findMinDifference(nums, N, M):`   `    ``# Sorting given array` `    ``nums.sort()`   `    ``# Factors will contain the factors of the given integers` `    ``# in nums array` `    ``factors ``=` `[]` `    ``for` `i ``in` `range``(N):` `        ``factors.append(factorsOfNumber(nums[i]))`   `    ``# factorFreq will map the frequency of factors which is ` `    ``# less than or equal to M` `    ``factorFreq ``=` `defaultdict(``int``)` `    ``i ``=` `0` `    ``j ``=` `0`   `    ``# minDiff will contain our final answer` `    ``minDiff ``=` `math.inf`   `    ``# Using two pointer` `    ``while` `i < N ``and` `j < N:`   `        ``# If factorFreq size is equal to M, then we can` `        ``# increment the pointer i` `        ``if` `len``(factorFreq) ``=``=` `M:`   `            ``# Updating minDiff` `            ``minDiff ``=` `min``(minDiff, nums[j``-``1``] ``-` `nums[i])`   `            ``# Updating factorFreq` `            ``for` `k ``in` `range``(``len``(factors[i])):` `                ``if` `factors[i][k] <``=` `M:` `                    ``factorFreq[factors[i][k]] ``-``=` `1` `                    ``if` `factorFreq[factors[i][k]] ``=``=` `0``:` `                        ``del` `factorFreq[factors[i][k]]`   `            ``i ``+``=` `1`   `        ``# Otherwise we will increment the j pointer` `        ``else``:`   `            ``# Updating factorFreq` `            ``for` `k ``in` `range``(``len``(factors[j])):` `                ``if` `factors[j][k] <``=` `M:` `                    ``factorFreq[factors[j][k]] ``+``=` `1`   `            ``j ``+``=` `1`   `    ``# Checking if i

C#

 `// C# code for the approach` `using` `System;` `using` `System.Collections.Generic;` `using` `System.Linq;`   `class` `GFG {` `      ``// Driver's code` `    ``static` `void` `Main(``string``[] args)` `    ``{` `          ``// Input` `        ``int` `N = 5;` `        ``int` `M = 7;` `        ``int``[] nums = { 6, 4, 5, 3, 7 };` `          `  `          ``// Function call` `        ``Console.WriteLine(findMinDifference(nums, N, M));` `    ``}`   `    ``// Function to find the factors of a given integer` `    ``static` `List<``int``> factorsOfNumber(``int` `n)` `    ``{` `        ``List<``int``> factors = ``new` `List<``int``>{ 1 };` `        ``if` `(n == 1)` `            ``return` `factors;` `        ``for` `(``int` `i = 2; i * i <= n; i++) {` `            ``if` `(n % i == 0) {` `                ``if` `(n / i == i) {` `                    ``factors.Add(i);` `                ``}` `                ``else` `{` `                    ``factors.Add(i);` `                    ``factors.Add(n / i);` `                ``}` `            ``}` `        ``}` `        ``factors.Add(n);` `        ``return` `factors;` `    ``}` `    `  `      ``// Function to find the minimum difference of two selected` `    ``// integers` `    ``static` `int` `findMinDifference(``int``[] nums, ``int` `N, ``int` `M)` `    ``{` `        ``// Sorting given array` `        ``Array.Sort(nums);`   `        ``// Factors will contain the factors of the given` `        ``// integers in nums array` `        ``List > factors = ``new` `List >();` `        ``for` `(``int` `k = 0; k < N; k++) {` `            ``factors.Add(factorsOfNumber(nums[k]));` `        ``}`   `        ``// factorFreq will map the frequency of factors` `        ``// which is less than or equal to M` `        ``Dictionary<``int``, ``int``> factorFreq` `            ``= ``new` `Dictionary<``int``, ``int``>();` `        ``int` `i = 0;` `        ``int` `j = 0;`   `        ``// minDiff will contain our final answer` `        ``int` `minDiff = ``int``.MaxValue;`   `        ``// Using two pointer` `        ``while` `(i < N && j < N) {` `            ``// If factorFreq size is equal to M, then we can` `            ``// increment the pointer i` `            ``if` `(factorFreq.Count == M) {` `                ``// Updating minDiff` `                ``minDiff = Math.Min(minDiff,` `                                   ``nums[j - 1] - nums[i]);`   `                ``// Updating factorFreq` `                ``for` `(``int` `k = 0; k < factors[i].Count; k++) {` `                    ``if` `(factors[i][k] <= M) {` `                        ``factorFreq[factors[i][k]] -= 1;` `                        ``if` `(factorFreq[factors[i][k]]` `                            ``== 0) {` `                            ``factorFreq.Remove(` `                                ``factors[i][k]);` `                        ``}` `                    ``}` `                ``}`   `                ``i += 1;` `            ``}`   `            ``// Otherwise we will increment the j pointer` `            ``else` `{` `                ``// Updating factorFreq` `                ``for` `(``int` `k = 0; k < factors[j].Count; k++) {` `                    ``if` `(factors[j][k] <= M) {` `                        ``if` `(factorFreq.ContainsKey(` `                                ``factors[j][k])) {` `                            ``factorFreq[factors[j][k]] += 1;` `                        ``}` `                        ``else` `{` `                            ``factorFreq.Add(factors[j][k],` `                                           ``1);` `                        ``}` `                    ``}` `                ``}`   `                ``j += 1;` `            ``}` `        ``}`   `        ``// Checking if i

Javascript

 `// Javascript code implementation`   `function` `findMinDifference(nums, N, M){` `// Sorting given array` `nums.sort(``function``(a, b){``return` `a - b});`   `// Factors will contain the factors of the given integers` `// in nums array` `var` `factors = [];` `for` `(``var` `i = 0; i < N; i++){` `    ``factors.push(factorsOfNumber(nums[i]));` `}`   `// factorFreq will map the frequency of factors which is ` `// less than or equal to M` `var` `factorFreq = {};` `var` `i = 0;` `var` `j = 0;`   `// minDiff will contain our final answer` `var` `minDiff = Infinity;`   `// Using two pointer` `while` `(i < N && j < N){`   `    ``// If factorFreq size is equal to M, then we can` `    ``// increment the pointer i` `    ``if` `(Object.keys(factorFreq).length === M){`   `        ``// Updating minDiff` `        ``minDiff = Math.min(minDiff, nums[j-1] - nums[i]);`   `        ``// Updating factorFreq` `        ``for` `(``var` `k = 0; k < factors[i].length; k++){` `            ``if` `(factors[i][k] <= M){` `                ``factorFreq[factors[i][k]] -= 1;` `                ``if` `(factorFreq[factors[i][k]] === 0){` `                    ``delete` `factorFreq[factors[i][k]];` `                ``}` `            ``}` `        ``}`   `        ``i += 1;`   `    ``// Otherwise we will increment the j pointer` `    ``} ``else` `{`   `        ``// Updating factorFreq` `        ``for` `(``var` `k = 0; k < factors[j].length; k++){` `            ``if` `(factors[j][k] <= M){` `                ``if` `(factorFreq[factors[j][k]]){` `                    ``factorFreq[factors[j][k]] += 1;` `                ``} ``else` `{` `                    ``factorFreq[factors[j][k]] = 1;` `                ``}` `            ``}` `        ``}`   `        ``j += 1;`   `    ``}` `}`   `// Checking if i

Output

`3`

Time Complexity: O(N* sqrt(N))
Auxiliary Space: O(N * sqrt(N))

My Personal Notes arrow_drop_up