Get the best out of our app
GFG App
Open App
Browser
Continue

# Minimize Array length by repeatedly replacing co-prime pairs with 1

Given an array arr[] consisting of N elements, the task is to minimize the array length by replacing any two coprime array elements with 1.
Examples:

Input: arr[] = {2, 3, 5}
Output:
Explanation:
Replace {2, 3} with 1 modifies the array to {1, 5}.
Replace {1, 5} with 1 modifies the array to {1}.
Input: arr[] = {6, 9, 15}
Output:
Explanation: No coprime pairs exist in the array. Therefore, no reduction possible.

Naive Approach: The simplest approach is to iterate over the array and check for coprime pairs. If found replace it with 1 search for the next coprime pair and so on.

Time Complexity: O(N * log N)
Auxiliary Space: O(1)

Efficient Approach: This approach is based on the fact:

1 is coprime with every number

The idea is to find if there is any co-prime pair present in the array or not. If found, then all the array elements can be reduced to 1 based on the above fact. Hence, if any co-prime pair is found, then, the required answer will be 1, else, the answer will be the initial size of the array.

Illustration:
For arr[] = {2, 4, 6, 8, 9}
Here, as there exists a coprime pair {2, 9}, replacing them by 1 modifies the array to {1, 4, 6, 8}.
Since 1 is coprime with every number, the array can be reduced further in following steps:
{1, 4, 6, 8} -> {1, 6, 8} -> {1, 8} -> {1}
Hence, the array can be reduced to size 1.

Below is the implementation of the above approach:

## C++

 `// C++ Program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the final array` `// length by replacing coprime pair with 1` `bool` `hasCoprimePair(vector<``int``>& arr, ``int` `n)` `{`   `    ``// Iterate over all pairs of element` `    ``for` `(``int` `i = 0; i < n - 1; i++) {` `        ``for` `(``int` `j = i + 1; j < n; j++) {`   `            ``// Check if gcd is 1` `            ``if` `(__gcd(arr[i], arr[j]) == 1) {` `                ``return` `true``;` `            ``}` `        ``}` `    ``}`   `    ``// If no coprime pair` `    ``// found return false` `    ``return` `false``;` `}`   `// Driver code` `int` `main()` `{`   `    ``int` `n = 3;` `    ``vector<``int``> arr = { 6, 9, 15 };`   `    ``// Check if atleast one coprime` `    ``// pair exists in the array` `    ``if` `(hasCoprimePair(arr, n)) {` `        ``cout << 1 << endl;` `    ``}`   `    ``// If no such pair exists` `    ``else` `{` `        ``cout << n << endl;` `    ``}` `}`

## Java

 `// Java Program for the above approach` `import` `java.util.*;` `class` `GFG{` `    `  `// Recursive function to return` `// gcd of a and b  ` `static` `int` `__gcd(``int` `a, ``int` `b)  ` `{  ` `    ``return` `b == ``0``? a:__gcd(b, a % b);     ` `}`   `// Function to find the final array` `// length by replacing coprime pair with 1` `static` `boolean` `hasCoprimePair(``int` `[]arr, ``int` `n)` `{`   `    ``// Iterate over all pairs of element` `    ``for` `(``int` `i = ``0``; i < n - ``1``; i++) ` `    ``{` `        ``for` `(``int` `j = i + ``1``; j < n; j++) ` `        ``{`   `            ``// Check if gcd is 1` `            ``if` `((__gcd(arr[i], arr[j])) == ``1``)` `            ``{` `                ``return` `true``;` `            ``}` `        ``}` `    ``}`   `    ``// If no coprime pair` `    ``// found return false` `    ``return` `false``;` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `n = ``3``;` `    ``int` `[]arr = { ``6``, ``9``, ``15` `};`   `    ``// Check if atleast one coprime` `    ``// pair exists in the array` `    ``if` `(hasCoprimePair(arr, n))` `    ``{` `        ``System.out.print(``1` `+ ``"\n"``);` `    ``}`   `    ``// If no such pair exists` `    ``else` `    ``{` `        ``System.out.print(n + ``"\n"``);` `    ``}` `}` `}`   `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program for the above approach` `import` `math`   `# Function to find the final array` `# length by replacing coprime pair with 1` `def` `hasCoprimePair(arr, n):`   `    ``# Iterate over all pairs of element` `    ``for` `i ``in` `range``(n ``-` `1``):` `        ``for` `j ``in` `range``(i ``+` `1``, n):`   `            ``# Check if gcd is 1` `            ``if` `(math.gcd(arr[i], arr[j]) ``=``=` `1``):` `                ``return` `True` `            `  `    ``# If no coprime pair` `    ``# found return false` `    ``return` `False`   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``n ``=` `3` `    ``arr ``=` `[ ``6``, ``9``, ``15` `]`   `    ``# Check if atleast one coprime` `    ``# pair exists in the array` `    ``if` `(hasCoprimePair(arr, n)):` `        ``print``(``1``)` `    `  `    ``# If no such pair exists` `    ``else``:` `        ``print``(n)` `    `  `# This code is contributed by chitranayal`

## C#

 `// C# Program for the above approach` `using` `System;` `class` `GFG{` `    `  `// Recursive function to return` `// gcd of a and b  ` `static` `int` `__gcd(``int` `a, ``int` `b)  ` `{  ` `    ``return` `b == 0 ? a : __gcd(b, a % b);     ` `}`   `// Function to find the readonly array` `// length by replacing coprime pair with 1` `static` `bool` `hasCoprimePair(``int` `[]arr, ``int` `n)` `{`   `    ``// Iterate over all pairs of element` `    ``for` `(``int` `i = 0; i < n - 1; i++) ` `    ``{` `        ``for` `(``int` `j = i + 1; j < n; j++) ` `        ``{`   `            ``// Check if gcd is 1` `            ``if` `((__gcd(arr[i], ` `                       ``arr[j])) == 1)` `            ``{` `                ``return` `true``;` `            ``}` `        ``}` `    ``}`   `    ``// If no coprime pair` `    ``// found return false` `    ``return` `false``;` `}`   `// Driver code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `n = 3;` `    ``int` `[]arr = { 6, 9, 15 };`   `    ``// Check if atleast one coprime` `    ``// pair exists in the array` `    ``if` `(hasCoprimePair(arr, n))` `    ``{` `        ``Console.Write(1 + ``"\n"``);` `    ``}`   `    ``// If no such pair exists` `    ``else` `    ``{` `        ``Console.Write(n + ``"\n"``);` `    ``}` `}` `}`   `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output:

`3`

Time Complexity: O(N2 * log N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Similar Reads
Related Tutorials