# Find GCD of all Array elements except the multiples of K

• Last Updated : 09 May, 2022

Given an array arr[] of N integers and an integer K, the task is to find the GCD of all the array elements except the ones which are divisible by K.

Examples:

Input: arr[] = {2, 4, 6, 8, 10}, N = 5, K = 10
Output: 2
Explanation: The multiple of K is 10.
Remaining elements are 2, 4, 6 and 8 the gcd of which are 2.

Input: arr[] ={45, 15, 90, 20, 10}, N = 5, K = 15
Output: 10

Approach: The basic approach for this problem is to find the multiples of K first and then find the GCD of the remaining elements.

Follow the below steps to solve this problem:

• Iterate through all elements of an array
• Store all the elements of an array that are not divisible by K.
• Then for remaining elements, find the GCD of all the numbers.
• Return the GCD value.

Below is the implementation of the above approach:

## C++

 `// C++ code to implement the approach` `#include ``using` `namespace` `std;` `// Function to print GCD``int` `findPrime(``int` `arr[], ``int` `n, ``int` `k)``{``    ``int` `i, hcf;``    ``int` `c = 0;` `    ``// Vector used to store all the elements``    ``// which are not divisible by k``    ``vector<``int``> v;` `    ``for` `(i = 0; i < n; i++) {``        ``if` `(arr[i] % k == 0)``            ``continue``;``        ``else``            ``v.push_back(arr[i]);``    ``}``    ``if` `(v.size() == 0) {``        ``cout << ``"NO"``;``    ``}``    ``else` `if` `(v.size() == 1) {``        ``hcf = v;``    ``}``    ``else` `{``        ` `        ``// Finding the gcd using built in``        ``// function __gcd(value1,value2);``        ``hcf = __gcd(v, v);``        ``for` `(i = 2; i < v.size(); i++) {``            ``hcf = __gcd(arr[i], hcf);``        ``}``    ``}``    ``return` `hcf;``}` `// Driver Code``int` `main()``{``    ``int` `N = 5;``    ``int` `K = 10;``    ``int` `arr[] = { 2, 4, 6, 8, 10 };``    ` `    ``// Function call``    ``cout << findPrime(arr, N, K);``    ``return` `0;``}`

## C

 `// C code to implement the approach``#include ``#include ` `int` `gcd(``int` `a, ``int` `b)``{``  ` `    ``// Everything divides 0``    ``if` `(a == 0)``       ``return` `b;``    ``if` `(b == 0)``       ``return` `a;`` ` `    ``// base case``    ``if` `(a == b)``        ``return` `a;`` ` `    ``// a is greater``    ``if` `(a > b)``        ``return` `gcd(a-b, b);``    ``return` `gcd(a, b-a);``}` `// Function to print GCD``int` `findPrime(``int` `arr[], ``int` `n, ``int` `k)``{``    ``int` `i, hcf;``    ``int` `c = 0;` `    ``// array used to store all the elements``    ``// which are not divisible by k``    ``int` `v;``    ``int` `index=0;` `    ``for` `(i = 0; i < n; i++) {``        ``if` `(arr[i] % k == 0)``            ``continue``;``        ``else``        ``{``          ``v[index]=arr[i];``          ``index++;``        ``}``            ` `    ``}``    ``if` `(index == 0) {``        ``printf``(``"NO"``);``    ``}``    ``else` `if` `(index == 1) {``        ``hcf = v;``    ``}``    ``else` `{``        ` `        ``// Finding the gcd using``        ``// gcd function declared above``        ``hcf = gcd(v, v);``        ``for` `(i = 2; i < index+1; i++) {``            ``hcf = gcd(arr[i], hcf);``        ``}``    ``}``    ``return` `hcf;``}` `// Driver Code``void` `main()``{``    ``int` `N = 5;``    ``int` `K = 10;``    ``int` `arr = { 2, 4, 6, 8, 10 };``    ` `    ``// Function call``    ``int` `ans =  findPrime(arr, N, K);``    ``printf``(``"%d"``,ans);``}`

## Java

 `// Java code to implement the approach``import` `java.util.*;` `class` `GFG {` `  ``// Function to calculate GCD ``  ``static` `int` `gcd(``int` `a, ``int` `b)  ``  ``{  ``    ``if` `(b == ``0``)  ``      ``return` `a;    ``    ``return` `gcd(b, a % b);  ``  ``}  ` `  ``// Function to print GCD``  ``static` `int` `findPrime(``int` `arr[], ``int` `n, ``int` `k)``  ``{``    ``int` `i, hcf = ``0``;``    ``int` `c = ``0``;` `    ``// Vector used to store all the elements``    ``// which are not divisible by k``    ``Vector v = ``new` `Vector();` `    ``for` `(i = ``0``; i < n; i++) {``      ``if` `(arr[i] % k == ``0``)``        ``continue``;``      ``else``        ``v.add(arr[i]);``    ``}``    ``if` `(v.size() == ``0``) {``      ``System.out.println(``"NO"``);``    ``}``    ``else` `if` `(v.size() == ``1``) {``      ``hcf = v.get(``0``);``    ``}``    ``else` `{` `      ``// Finding the gcd using built in``      ``// function __gcd(value1,value2);``      ``hcf = gcd(v.get(``0``), v.get(``1``));``      ``for` `(i = ``2``; i < v.size(); i++) {``        ``hcf = gcd(arr[i], hcf);``      ``}``    ``}``    ``return` `hcf;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main (String[] args)``  ``{` `    ``int` `N = ``5``;``    ``int` `K = ``10``;``    ``int` `arr[] = { ``2``, ``4``, ``6``, ``8``, ``10` `};` `    ``// Function call``    ``System.out.println(findPrime(arr, N, K));``  ``}``}` `// This code is contributed by hrithikgarg03188.`

## Python3

 `# Python code to implement the approach` `# Function for GCD``def` `__gcd(a, b):``    ``if` `(b ``=``=` `0``):``        ``return` `a``    ``return` `__gcd(b, a ``%` `b)` `# Function to print GCD``def` `findPrime(arr, n, k):``    ``c ``=` `0` `    ``# Vector used to store all the elements``    ``# which are not divisible by k``    ``v ``=` `[]` `    ``for` `i ``in` `range``(n):``        ``if` `(arr[i] ``%` `k ``=``=` `0``):``            ``continue``        ``else``:``            ``v.append(arr[i])` `    ``if` `(``len``(v) ``=``=` `0``):``        ``print``(``"NO"``)``    ``elif` `(``len``(v) ``=``=` `1``):``        ``hcf ``=` `v[``0``]``    ``else``:` `        ``# Finding the gcd using built in``        ``# function __gcd(value1,value2);``        ``hcf ``=` `__gcd(v[``0``], v[``1``])``        ``for` `i ``in` `range``(``2``, ``len``(v)):``            ``hcf ``=` `__gcd(arr[i], hcf)` `    ``return` `hcf` `# Driver Code``N ``=` `5``K ``=` `10``arr ``=` `[``2``, ``4``, ``6``, ``8``, ``10``]` `# Function call``print``(findPrime(arr, N, K))` `# This code is contributed by shinjanpatra`

## C#

 `// C# code to implement the approach``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG``{``  ` `  ``// Function to calculate GCD ``  ``static` `int` `gcd(``int` `a, ``int` `b)  ``  ``{  ``    ``if` `(b == 0)  ``      ``return` `a;    ``    ``return` `gcd(b, a % b);  ``  ``}  ` `  ``// Function to print GCD``  ``static` `int` `findPrime(``int``[] arr, ``int` `n, ``int` `k)``  ``{``    ``int` `i;``    ``int` `hcf = 0;` `    ``// Vector used to store all the elements``    ``// which are not divisible by k``    ``List<``int``> v = ``new` `List<``int``>();` `    ``for` `(i = 0; i < n; i++) {``      ``if` `(arr[i] % k == 0)``        ``continue``;``      ``else``        ``v.Add(arr[i]);``    ``}``    ``if` `(v.Count == 0) {``      ``Console.WriteLine(``"NO"``);``    ``}``    ``else` `if` `(v.Count == 1) {``      ``hcf = v;``    ``}``    ``else` `{` `      ``// Finding the gcd using built in``      ``// function __gcd(value1,value2);``      ``hcf = gcd(v, v);``      ``for` `(i = 2; i < v.Count; i++) {``        ``hcf = gcd(arr[i], hcf);``      ``}``    ``}``    ``return` `hcf;``  ``}` `  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``int` `N = 5;``    ``int` `K = 10;``    ``int``[] arr = { 2, 4, 6, 8, 10 };` `    ``// Function call``    ``Console.WriteLine(findPrime(arr, N, K));``  ``}``}` `// This code is contributed by phasing17`

## Javascript

 ``

Output

`2`

Time Complexity: O(N * log M), where M is the maximum element of the array
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up