Skip to content
Related Articles

Related Articles

Check if all array elements can be reduced to less than X

View Discussion
Improve Article
Save Article
  • Last Updated : 04 May, 2021
View Discussion
Improve Article
Save Article

Given an array A[] consisting of N positive integers and an integer X, the task is to determine if it is possible to convert all array elements to less than X by performing the following operations:

  • Select 2 distinct indices j and k.
  • Select an index i, where A[i] > X.
  • Replace A[i] = gcd(A[j], A[k]) if and only if gcd(A[j], A[k]) ≠ 1.

Examples: 

Input: A[] = {2, 1, 5, 3, 6}, X = 4 
Output: Yes 
Explanation:

  • Selecting i = 3, j = 4, k = 5, set A[i] = gcd(A[j], A[k]) = 3. Therefore, A[] modifies to {2, 1, 3, 3, 6}.
  • Selecting i = 5, j = 4, k = 5, set A[i] = gcd(A[j], A[k]) = 3. Therefore, A[] modifies to {2, 1, 3, 3, 3}.

Input: A[] = {2, 3, 2, 5, 4}, X = 3 
Output: Yes

Approach: Follow the steps below to solve the problem: 

  1. Find the two numbers having gcd ≠ 1 as well as gcd ≤ X, then, by using these two numbers, the required number A[i] can be replaced with gcd(A[j], A[k]).
  2. Using the fact that gcd(x, y) ≤ min(x, y), the array elements can be reduced to ≤ X.
  3. This way, the rest of the array can be converted to ≤ X using step 2.

Below is the implementation of the above approach:

C++




// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if all array
// elements are≤ X
bool check(int A[], int X, int N)
{
    for(int i = 0; i < N; i++)
    {
        if (A[i] > X)
        {
            return false;
        }
    }
    return true;
}
 
// Function to check if all array elements
// can be reduced to less than X or not
bool findAns(int A[], int N, int X)
{
     
    // Checks if all array elements
    // are already ≤ X or not
    if (check(A, X, N))
    {
        return true;
    }
 
    // Traverse every possible pair
    for(int i = 0; i < N; i++)
    {
        for(int j = i + 1; j < N; j++)
        {
             
            // Calculate GCD of two
            // array elements
            int g = __gcd(A[i], A[j]);
 
            // If gcd is ≠ 1
            if (g != 1)
            {
                 
                // If gcd is ≤ X, then a pair
                // is present to reduce all
                // array elements to ≤ X
                if (g <= X)
                {
                    return true;
                }
            }
        }
    }
     
    // If no pair is present
    // with gcd is ≤ X
    return false;
}
 
// Driver Code
int main()
{
    int X = 4;
    int A[] = { 2, 1, 5, 3, 6 };
    int N = 5;
     
    if (findAns(A, N, X))
    {
        cout << "true";
    }
    else
    {
        cout << "false";
    }
}
 
// This code is contributed by mohit kumar 29

Java



// Java Program to implement
// the above approach
 
import java.io.*;
import java.util.Arrays;
 
class GFG {
 
    // Function to check if all array elements
    // can be reduced to less than X or not
    public static boolean findAns(
        int[] A, int N, int X)
    {
        // Checks if all array elements
        // are already ≤ X or not
        if (check(A, X)) {
            return true;
        }
 
        // Traverse every possible pair
        for (int i = 0; i < N; i++) {
            for (int j = i + 1; j < N; j++) {
 
                // Calculate GCD of two
                // array elements
                int gcd = gcd(A[i], A[j]);
 
                // If gcd is ≠ 1
                if (gcd != 1) {
 
                    // If gcd is ≤ X, then a pair
                    // is present to reduce all
                    // array elements to ≤ X
                    if (gcd <= X) {
 
                        return true;
                    }
                }
            }
        }
 
        // If no pair is present
        // with gcd is ≤ X
        return false;
    }
 
    // Function to check if all array elements are≤ X
    public static boolean check(int[] A, int X)
    {
        for (int i = 0; i < A.length; i++) {
            if (A[i] > X) {
                return false;
            }
        }
        return true;
    }
 
    // Function to calculate gcd of two numbers
    public static int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int X = 4;
        int[] A = { 2, 1, 5, 3, 6 };
        int N = 5;
 
        System.out.println(findAns(A, N, X));
    }
}
Python3



# Python3 program to implement
# the above approach
 
# Function to check if all array elements
# can be reduced to less than X or not
def findAns(A, N, X):
   
  # Checks if all array elements
  # are already ≤ X or not
  if (check(A, X)):
    return True
         
  # Traverse every possible pair
  for i in range(N):
    for j in range(i + 1, N):
       
      # Calculate GCD of two
      # array elements
      gcd = GCD(A[i], A[j])
 
      # If gcd is ≠ 1
      if (gcd != 1):
         
        # If gcd is ≤ X, then a pair
        # is present to reduce all
        # array elements to ≤ X
        if (gcd <= X):
          return True
 
  # If no pair is present
  # with gcd is ≤ X
  return False
 
# Function to check if all array elements are≤ X
def check(A, X):
  for i in range(len(A)):
    if (A[i] > X):
      return False
  return True
 
# Function to calculate gcd of two numbers
def GCD(a, b):
  if (b == 0):
    return a
  return GCD(b, a % b)
 
# Driver Code
X = 4
A = [ 2, 1, 5, 3, 6 ]
N = 5
 
print(findAns(A, N, X))
 
# This code is contributed by rohitsingh07052
C#



// C# Program to implement
// the above approach
using System;
class GFG {
 
    // Function to check if all array elements
    // can be reduced to less than X or not
    public static bool findAns(
        int[] A, int N, int X)
    {
        // Checks if all array elements
        // are already ≤ X or not
        if (check(A, X))
        {
            return true;
        }
 
        // Traverse every possible pair
        for (int i = 0; i < N; i++)
        {
            for (int j = i + 1; j < N; j++)
            {
 
                // Calculate GCD of two
                // array elements
                int gcd = gcdFoo(A[i], A[j]);
 
                // If gcd is ≠ 1
                if (gcd != 1)
                {
 
                    // If gcd is ≤ X, then a pair
                    // is present to reduce all
                    // array elements to ≤ X
                    if (gcd <= X)
                    {
                        return true;
                    }
                }
            }
        }
 
        // If no pair is present
        // with gcd is ≤ X
        return false;
    }
 
    // Function to check if all array elements are≤ X
    public static bool check(int[] A, int X)
    {
        for (int i = 0; i < A.Length; i++)
        {
            if (A[i] > X)
            {
                return false;
            }
        }
        return true;
    }
 
    // Function to calculate gcd of two numbers
    static int gcdFoo(int a, int b)
    {
        if (b == 0)
            return a;
        return gcdFoo(b, a % b);
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int X = 4;
        int[] A = { 2, 1, 5, 3, 6 };
        int N = 5;
 
        Console.WriteLine(findAns(A, N, X));
    }
}
 
// This code is contributed by 29AjayKumar
Javascript



<script>
// javascript program of the above approach
 
    // Function to check if all array elements
    // can be reduced to less than X or not
    function findAns(
         A, N, X)
    {
        // Checks if all array elements
        // are already ≤ X or not
        if (check(A, X)) {
            return true;
        }
  
        // Traverse every possible pair
        for (let i = 0; i < N; i++) {
            for (let j = i + 1; j < N; j++) {
  
                // Calculate GCD of two
                // array elements
                let gcdd = gcd(A[i], A[j]);
  
                // If gcd is ≠ 1
                if (gcdd != 1) {
  
                    // If gcd is ≤ X, then a pair
                    // is present to reduce all
                    // array elements to ≤ X
                    if (gcdd <= X) {
  
                        return true;
                    }
                }
            }
        }
  
        // If no pair is present
        // with gcd is ≤ X
        return false;
    }
  
    // Function to check if all array elements are≤ X
    function check(A, X)
    {
        for (let i = 0; i < A.length; i++) {
            if (A[i] > X) {
                return false;
            }
        }
        return true;
    }
  
    // Function to calculate gcd of two numbers
    function gcd(a, b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
  
 
    // Driver Code
     
        let X = 4;
        let A = [ 2, 1, 5, 3, 6 ];
        let N = 5;
  
        document.write(findAns(A, N, X));
 
// This code is contributed by target_2.
</script>
Output
true
 Time Complexity: O(N2) 
Auxiliary Space: O(1)
 

My Personal Notes
arrow_drop_up
Next

Check if X and Y elements can be selected from two arrays respectively such that the maximum in X is less than the minimum in Y
Recommended Articles
Page :
Check if given Array can be reduced to 0 by removing element less than K and adding it to K
12, Jan 22
Check if all array elements can be reduced to 0 by repeatedly reducing pairs of consecutive elements by their minimum
08, Feb 21
Numbers less than N that are perfect cubes and the sum of their digits reduced to a single digit is 1
08, Feb 19
Check if sum of the given array can be reduced to 0 by reducing array elements by K
03, Jan 21
Count the numbers that can be reduced to zero or less in a game
17, Jan 19
Check if an array can be reduced to at most length K by removal of distinct elements
15, Jun 21
Maximum number of times Array can be reduced in half when its all elements are even
10, Aug 21
Maximise K that can be reduced from Array to make all elements equal
19, Jan 22
Check if sum of array can be reduced to zero by repetitively reducing array element by their index value
06, Oct 20
Sum of all array elements less than X and greater than Y for Q queries
18, Jun 20
Check whether each Array element can be reduced to minimum element by replacing it with remainder with some X
20, Aug 21
Check if the given array can be reduced to zeros with the given operation performed given number of times
13, Mar 19
Minimum decrements to make an Array at most 0 such that all array elements are cyclically decremented after a number is reduced to 0
16, Nov 21
For each A[i] find smallest subset with all elements less than A[i] sum more than B[i]
21, Mar 22
Arrange N elements in circular fashion such that all elements are strictly less than sum of adjacent elements
11, Jul 19
Check if A and B can be reduced to 0 by decrementing with x and y with absolute difference at most K
19, Oct 21
Check if X can be reduced to 0 in exactly T moves by subtracting D or 1 from it
13, Aug 21
Check if any subarray can be made palindromic by replacing less than half of its elements
02, Dec 20
Check if X and Y elements can be selected from two arrays respectively such that the maximum in X is less than the minimum in Y
20, Jan 21
Count of indices in Array having all prefix elements less than all in suffix
10, Mar 22
Length of longest subarray in which elements greater than K are more than elements not greater than K
14, Aug 19
Minimize Array elements to be reduced to make subsequences sum 1 to Array max possible
13, Jan 22
Minimize deletions in Array by deleting all occurrences of any number such that array size is reduced to at least half
03, Sep 21
Sum of elements in 1st array such that number of elements less than or equal to them in 2nd array is maximum
17, Apr 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
aditya7409
@aditya7409
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!