Skip to content
Related Articles

Related Articles

Improve Article
Modify array by replacing elements with their farthest co-prime number from a given range
  • Last Updated : 05 May, 2021

Given an array arr[] consisting of N integers and two positive integers L and R, the task is to find the farthest co-prime number in the range [L, R] for every array element.

Examples:

Input: arr[] = {5, 150, 120}, L = 2, R = 250
Output: 249 7 247
Explanation:
The number which is co-prime with arr[0] and farthest from it is 249.
The number which is co-prime with arr[1] and farthest from it is 7.
The number which is co-prime with arr[2] and farthest from it is 247.

Input: arr[] = {60, 246, 75, 103, 155, 110}, L = 2, R = 250
Output: 60 246 75 103 155 110

Approach: The given problem can be solved by iterating over the given range [L, R] for every array element and find the farthest element from it having GCD 1 with the array element. Follow the steps below to solve the problem:



  • Traverse the given array arr[] and perform the following steps:
    • Initialize two variables, say d as 0 and coPrime as -1, to store the farthest distance and the number coprime with the arr[i] respectively.
    • Iterate over the given range [L, R] and perform the following steps:
      • Update the value of d as the absolute difference of arr[i] and j.
      • If the greatest common divisor of arr[i] and j is 1 and d is less than abs(arr[i] – j), then update the value of coPrime as j.
    • Update the value of arr[i] as the coPrime.
  • After completing the above steps, print the array arr[] as the resultant array.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate GCD
// of the integers a and b
int gcd(int a, int b)
{
    // Base Case
    if (a == 0)
        return b;
 
    // Recursively find the GCD
    return gcd(b % a, a);
}
 
// Function to find the farthest
// co-prime number over the range
// [L, R] for each array element
void update(int arr[], int n)
{
    // Traverse the array arr[]
    for (int i = 0; i < n; i++) {
 
        // Stores the distance
        // between j and arr[i]
        int d = 0;
 
        // Stores the integer coprime
        // which is coprime is arr[i]
        int coPrime = -1;
 
        // Traverse the range [2, 250]
        for (int j = 2; j <= 250; j++) {
 
            // If gcd of arr[i] and j is 1
            if (gcd(arr[i], j) == 1
                && d < abs(arr[i] - j)) {
 
                // Update the value of d
                d = abs(arr[i] - j);
 
                // Update the value
                // of coPrime
                coPrime = j;
            }
        }
 
        // Update the value of arr[i]
        arr[i] = coPrime;
    }
 
    // Print the array arr[]
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}
 
// Driver Code
int main()
{
    int arr[] = { 60, 246, 75, 103, 155, 110 };
    int N = sizeof(arr) / sizeof(arr[0]);
    update(arr, N);
 
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG{
 
// Function to calculate GCD
// of the integers a and b
static int gcd(int a, int b)
{
     
    // Base Case
    if (a == 0)
        return b;
 
    // Recursively find the GCD
    return gcd(b % a, a);
}
 
// Function to find the farthest
// co-prime number over the range
// [L, R] for each array element
static void update(int arr[], int n)
{
     
    // Traverse the array arr[]
    for(int i = 0; i < n; i++)
    {
         
        // Stores the distance
        // between j and arr[i]
        int d = 0;
 
        // Stores the integer coprime
        // which is coprime is arr[i]
        int coPrime = -1;
 
        // Traverse the range [2, 250]
        for(int j = 2; j <= 250; j++)
        {
             
            // If gcd of arr[i] and j is 1
            if (gcd(arr[i], j) == 1 &&
                d < Math.abs(arr[i] - j))
            {
                 
                // Update the value of d
                d = Math.abs(arr[i] - j);
 
                // Update the value
                // of coPrime
                coPrime = j;
            }
        }
 
        // Update the value of arr[i]
        arr[i] = coPrime;
    }
 
    // Print the array arr[]
    for(int i = 0; i < n; i++)
        System.out.print(arr[i] + " ");
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 60, 246, 75, 103, 155, 110 };
    int N = arr.length;
     
    update(arr, N);
}
}
 
// This code is contributed by Kingash

Python3




# python 3 program for the above approach
from math import gcd
 
# Function to find the farthest
# co-prime number over the range
# [L, R] for each array element
def update(arr, n):
   
    # Traverse the array arr[]
    for i in range(n):
       
        # Stores the distance
        # between j and arr[i]
        d = 0
 
        # Stores the integer coprime
        # which is coprime is arr[i]
        coPrime = -1
 
        # Traverse the range [2, 250]
        for j in range(2, 251, 1):
           
            # If gcd of arr[i] and j is 1
            if (gcd(arr[i], j) == 1 and d < abs(arr[i] - j)):
               
                # Update the value of d
                d = abs(arr[i] - j)
 
                # Update the value
                # of coPrime
                coPrime = j
 
        # Update the value of arr[i]
        arr[i] = coPrime
 
    # Print the array arr[]
    for i in range(n):
        print(arr[i],end =" ")
 
# Driver Code
if __name__ == '__main__':
    arr = [60, 246, 75, 103, 155, 110]
    N = len(arr)
    update(arr, N)
     
    # This code is contributed by ipg2016107.

C#




// C# program for the above approach
using System;
 
class GFG {
 
    // Function to calculate GCD
    // of the integers a and b
    static int gcd(int a, int b)
    {
 
        // Base Case
        if (a == 0)
            return b;
 
        // Recursively find the GCD
        return gcd(b % a, a);
    }
 
    // Function to find the farthest
    // co-prime number over the range
    // [L, R] for each array element
    static void update(int[] arr, int n)
    {
 
        // Traverse the array arr[]
        for (int i = 0; i < n; i++) {
 
            // Stores the distance
            // between j and arr[i]
            int d = 0;
 
            // Stores the integer coprime
            // which is coprime is arr[i]
            int coPrime = -1;
 
            // Traverse the range [2, 250]
            for (int j = 2; j <= 250; j++) {
 
                // If gcd of arr[i] and j is 1
                if (gcd(arr[i], j) == 1
                    && d < Math.Abs(arr[i] - j)) {
 
                    // Update the value of d
                    d = Math.Abs(arr[i] - j);
 
                    // Update the value
                    // of coPrime
                    coPrime = j;
                }
            }
 
            // Update the value of arr[i]
            arr[i] = coPrime;
        }
 
        // Print the array arr[]
        for (int i = 0; i < n; i++)
            Console.Write(arr[i] + " ");
    }
 
    // Driver Code
    public static void Main(string[] args)
    {
        int[] arr = { 60, 246, 75, 103, 155, 110 };
        int N = arr.Length;
 
        update(arr, N);
    }
}
 
// This code is contributed by ukasp.

Javascript




<script>
 
// JavaScript program to implement
// the above approach
 
// Function to calculate GCD
// of the letegers a and b
function gcd(a, b)
{
      
    // Base Case
    if (a == 0)
        return b;
  
    // Recursively find the GCD
    return gcd(b % a, a);
}
  
// Function to find the farthest
// co-prime number over the range
// [L, R] for each array element
function update(arr, n)
{
      
    // Traverse the array arr[]
    for(let i = 0; i < n; i++)
    {
          
        // Stores the distance
        // between j and arr[i]
        let d = 0;
  
        // Stores the leteger coprime
        // which is coprime is arr[i]
        let coPrime = -1;
  
        // Traverse the range [2, 250]
        for(let j = 2; j <= 250; j++)
        {
              
            // If gcd of arr[i] and j is 1
            if (gcd(arr[i], j) == 1 &&
                d < Math.abs(arr[i] - j))
            {
                  
                // Update the value of d
                d = Math.abs(arr[i] - j);
  
                // Update the value
                // of coPrime
                coPrime = j;
            }
        }
  
        // Update the value of arr[i]
        arr[i] = coPrime;
    }
  
    // Prlet the array arr[]
    for(let i = 0; i < n; i++)
        document.write(arr[i] + " ");
}
 
 
// Driver code
 
     
    let arr = [ 60, 246, 75, 103, 155, 110 ];
    let N = arr.length;
      
    update(arr, N)
      
</script>
Output: 
247 5 248 250 2 249

 

Time Complexity: O((R – L) * N)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live 




My Personal Notes arrow_drop_up
Recommended Articles
Page :