# Check if GCD of [L, R] can be made >1 by replacing pairs with their product at most K times

Given a range **[L, R]** and an integer **K**, the task is to check if it is possible to make the GCD of all integers in the given range more than **1** using at most **K** operations wherein each operation replace any two integers in the range with their product.

**Examples:**

Input:L = 1, R = 5, K = 3 .Output:YesExplanation:All the integers in the given range are {1, 2, 3, 4, 5}. In first operation, replace the first two elements with their product. Hence, the remaining elements become {2, 3, 4, 5}. Similarly, {2, 3, 4, 5} => {2, 3, 20} => {2, 60}. Hence, in three operations the given range can be reduced to {2, 60} such that its GCD is greater than 1.

Input:L = 1, R = 2, K = 0Output:No

**Approach:** The given problem can be solved using a greedy approach. The idea is to find the most common prime factor among all the integers in the range so that other elements can be merged with them. It can be observed that the most common prime factor in all cases will be **2**. Hence, the most optimal choice is to multiply all odd integers with their nearest even integer. Therefore, if the count of odd integers if more than **K**, it is possible otherwise not.

Below is the implementation of the above approach:

## C++

`// C++ program of the above approach` `#include <iostream>` `using` `namespace` `std;` `// Function to check if it is possible` `// to make GCD of all integers in the` `// given range more than 1 with the` `// help of at most K operations` `bool` `gcdGreaterThanOne(` `int` `L, ` `int` `R, ` `int` `K)` `{` ` ` `// Case where the range` ` ` `// has only one integer` ` ` `if` `(L == R) {` ` ` `if` `(L == 1)` ` ` `return` `false` `;` ` ` `else` ` ` `return` `true` `;` ` ` `}` ` ` `// Stores the count of` ` ` `// odd integers in [L, R]` ` ` `int` `odd = (R - L + 1)` ` ` `- (R / 2 - ((L - 1) / 2));` ` ` `return` `(odd > K) ? ` `false` `: ` `true` `;` `}` `// Driver function` `int` `main()` `{` ` ` `int` `L = 1;` ` ` `int` `R = 5;` ` ` `int` `K = 3;` ` ` `if` `(gcdGreaterThanOne(L, R, K))` ` ` `cout << ` `"Yes"` `;` ` ` `else` ` ` `cout << ` `"No"` `;` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;` `class` `GFG {` ` ` `// Function to check if it is possible` ` ` `// to make GCD of all integers in the` ` ` `// given range more than 1 with the` ` ` `// help of at most K operations` ` ` `static` `Boolean gcdGreaterThanOne(` `int` `L, ` `int` `R, ` `int` `K)` ` ` `{` ` ` `// Case where the range` ` ` `// has only one integer` ` ` `if` `(L == R) {` ` ` `if` `(L == ` `1` `)` ` ` `return` `false` `;` ` ` `else` ` ` `return` `true` `;` ` ` `}` ` ` `// Stores the count of` ` ` `// odd integers in [L, R]` ` ` `int` `odd = (R - L + ` `1` `)` ` ` `- (R / ` `2` `- ((L - ` `1` `) / ` `2` `));` ` ` `return` `(odd > K) ? ` `false` `: ` `true` `;` ` ` `}` ` ` `// Driver function` ` ` `public` `static` `void` `main (String[] args) {` ` ` `int` `L = ` `1` `;` ` ` `int` `R = ` `5` `;` ` ` `int` `K = ` `3` `;` ` ` `if` `(gcdGreaterThanOne(L, R, K))` ` ` `System.out.println(` `"Yes"` `); ` ` ` `else` ` ` `System.out.println(` `"No"` `); ` ` ` `}` `}` `// This code is contributed by hrithikgarg03188.` |

## Python3

`# Function to check if it is possible` `# to make GCD of all integers in the` `# given range more than 1 with the` `# help of at most K operations` `def` `gcdGreaterThanOne(L, R, K):` ` ` `# Case where the range` ` ` `# has only one integer` ` ` `if` `(L ` `=` `=` `R):` ` ` `if` `(L ` `=` `=` `1` `):` ` ` `return` `false` ` ` `else` `:` ` ` `return` `true` ` ` `# Stores the count of` ` ` `# odd integers in [L, R]` ` ` `odd ` `=` `(R ` `-` `L ` `+` `1` `) ` `-` `(R ` `/` `2` `-` `((L ` `-` `1` `) ` `/` `2` `))` ` ` `return` `(odd <` `=` `K)` `# Driver function` `L ` `=` `1` `R ` `=` `5` `K ` `=` `3` `if` `(gcdGreaterThanOne(L, R, K)):` ` ` `print` `(` `"Yes"` `)` `else` `:` ` ` `print` `(` `"No"` `)` `# This code is contributed by khatriharsh281` |

## C#

`// C# implementation for the above approach` `using` `System;` `class` `GFG{` ` ` `// Function to check if it is possible` ` ` `// to make GCD of all integers in the` ` ` `// given range more than 1 with the` ` ` `// help of at most K operations` ` ` `static` `Boolean gcdGreaterThanOne(` `int` `L, ` `int` `R, ` `int` `K)` ` ` `{` ` ` ` ` `// Case where the range` ` ` `// has only one integer` ` ` `if` `(L == R) {` ` ` `if` `(L == 1)` ` ` `return` `false` `;` ` ` `else` ` ` `return` `true` `;` ` ` `}` ` ` `// Stores the count of` ` ` `// odd integers in [L, R]` ` ` `int` `odd = (R - L + 1)` ` ` `- (R / 2 - ((L - 1) / 2));` ` ` `return` `(odd > K) ? ` `false` `: ` `true` `;` ` ` `}` `// Driver code` `static` `public` `void` `Main (){` ` ` `int` `L = 1;` ` ` `int` `R = 5;` ` ` `int` `K = 3;` ` ` `if` `(gcdGreaterThanOne(L, R, K))` ` ` `Console.Write(` `"Yes"` `); ` ` ` `else` ` ` `Console.Write(` `"No"` `);` `}` `}` `// This code is contributed by sanjoy_62.` |

## Javascript

`<script>` ` ` `// JavaScript code for the above approach` ` ` `// Function to check if it is possible` ` ` `// to make GCD of all integers in the` ` ` `// given range more than 1 with the` ` ` `// help of at most K operations` ` ` `function` `gcdGreaterThanOne(L, R, K)` ` ` `{` ` ` ` ` `// Case where the range` ` ` `// has only one integer` ` ` `if` `(L == R) {` ` ` `if` `(L == 1)` ` ` `return` `false` `;` ` ` `else` ` ` `return` `true` `;` ` ` `}` ` ` `// Stores the count of` ` ` `// odd integers in [L, R]` ` ` `let odd = (R - L + 1)` ` ` `- (R / 2 - ((L - 1) / 2));` ` ` `return` `(odd > K) ? ` `false` `: ` `true` `;` ` ` `}` ` ` `// Driver function` ` ` `let L = 1;` ` ` `let R = 5;` ` ` `let K = 3;` ` ` `if` `(gcdGreaterThanOne(L, R, K))` ` ` `document.write(` `"Yes"` `);` ` ` `else` ` ` `document.write(` `"No"` `);` ` ` `// This code is contributed by Potta Lokesh` ` ` `</script>` |

**Output**

Yes

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