Related Articles

# Sort an array in increasing order of GCD of their digits

• Last Updated : 13 Jul, 2021

Given an array arr[] consisting of N positive integers, the task is to sort the array arr[] according to the increasing order of GCD of digits of each element. If GCD of two or more elements are the same then, sort according to their values.

Examples:

Input: arr[] = {555, 363, 488, 244}
Output: 244 363 488 555
Explanation:
Following the GCD of the digits of each number:

1. 555: GCD(5, 5, 5) = 5.
2. 363: GCD(3, 6, 3) = 3.
3. 488: GCD(4, 8, 8) = 4.
4. 244: GCD(2, 4, 4) = 2.

After sorting according the given criteria, the order of elements are {244, 363, 488, 555}.

Input: arr[] = {555, 363, 488, 244, 444, 5}
Output: 244 363 444 488 5 555

Approach: The given problem can be solved by using the comparator function with the sort() function. The comparator function is defined as:

• It takes two arguments at a time and returns true if the GCD of the first argument is less than the second argument.
• If the GCD value is the same, then it returns true if the first argument is less than the second argument. Otherwise, return false.

Below is the implementation of the above approach:

## C++

 `// C++ program for above approach``#include``using` `namespace` `std;` `// Function to calculate GCD of two integers``int` `gcd(``int` `a, ``int` `b)``{``    ` `    ``// Base case``    ``if` `(b == 0)``        ``return` `a;``         ` `    ``// Recursively calculate GCD``    ``return` `gcd(b, a % b);``}`` ` `// Function to calculate GCD of``// digits of array elements``int` `keyFunc(``int` `n)``{``    ``int` `getGCD = 0;``     ` `    ``while` `(n > 0)``    ``{``        ``getGCD = gcd(n % 10, getGCD);`` ` `        ``// If at point GCD becomes 1,``        ``// return it``        ``if` `(getGCD == 1)``            ``return` `1;`` ` `        ``n = n / 10;``    ``}``    ``return` `getGCD;``}` `// Comparator function that compares ``// elements according to their gcd value.``bool` `compare(``int` `o1, ``int` `o2)``{``    ``int` `x = keyFunc(o1);``    ``int` `y = keyFunc(o2);``    ` `    ``if``(x == y)``    ``{``        ``return` `o1 < o2;``    ``}``    ``return` `x < y;``}` `// Function to sort an array in according``// to GCD of digits of array elements``void` `sortArrayByGCD(vector<``int``>arr)``{``    ``vector<``int``>list;``    ``for``(``int` `i : arr)``    ``{``        ``list.push_back(i);``    ``}``     ` `    ``// Sort the array according to gcd of``    ``// digits using comparator function``    ``sort(list.begin(), list.end(), compare);``    ` `    ``// Print the resultant array``    ``for``(``int` `i : list)``    ``{``        ``cout << i << ``" "``;``    ``}``}`` ` `// Driver code``int` `main()``{``    ``vector<``int``>arr = { 555, 363, 488, 244 };;``    ``sortArrayByGCD(arr);``}` `// This code is contributed by nirajgusain5`

## Java

 `// Java program for the above approach``import` `java.util.ArrayList;``import` `java.util.Collections;``import` `java.util.Comparator;` `class` `GFG{``    ` `// Function to calculate GCD of two integers``static` `int` `gcd(``int` `a, ``int` `b)``{``    ` `    ``// Base case``    ``if` `(b == ``0``)``        ``return` `a;``        ` `    ``// Recursively calculate GCD``    ``return` `gcd(b, a % b);``}` `// Function to calculate GCD of``// digits of array elements``static` `int` `keyFunc(``int` `n)``{``    ``int` `getGCD = ``0``;``    ` `    ``while` `(n > ``0``)``    ``{``        ``getGCD = gcd(n % ``10``, getGCD);` `        ``// If at point GCD becomes 1,``        ``// return it``        ``if` `(getGCD == ``1``)``            ``return` `1``;` `        ``n = n / ``10``;``    ``}``    ``return` `getGCD;``}` `// Function to sort an array in according``// to GCD of digits of array elements``public` `static` `void` `sortArrayByGCD(``int``[] arr)``{``    ``ArrayList list = ``new` `ArrayList();``    ``for``(``int` `i : arr)``    ``{``        ``list.add(i);``    ``}``    ` `    ``// Sort the array according to gcd of``    ``// digits using comparator function``    ``Collections.sort(list, ``new` `Comparator()``    ``{``        ``@Override``        ``public` `int` `compare(Integer o1, Integer o2)``        ``{``            ``int` `x = keyFunc(o1) - keyFunc(o2);``            ``if` `(x == ``0``)``            ``{``                ``if` `(o1 > o2)``                    ``x = ``1``;``                ``else``                    ``x = -``1``;``            ``}``            ``return` `x;``        ``}``    ``});``    ` `    ``// Print the resultant array``    ``for``(``int` `i : list)``    ``{``        ``System.out.print(i + ``" "``);``    ``}``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``555``, ``363``, ``488``, ``244` `};``    ``sortArrayByGCD(arr);``}``}` `// This code is contributed by abhinavjain194`

## Python3

 `# Python3 program for the above approach` `# Function to calculate``# GCD of two integers``def` `gcd(a, b):``  ` `    ``# Base Case``    ``if` `not` `b:``        ``return` `a``      ` `    ``# Recursively calculate GCD``    ``return` `gcd(b, a ``%` `b)` `# Function to calculate GCD``# of two array elements``def` `keyFunc(n):``    ``getGCD ``=` `int``(``str``(n)[``0``])``    ` `    ``# Update the getGCD``    ``for` `i ``in` `str``(n):``        ``getGCD ``=` `gcd(getGCD, ``int``(i))``        ` `    ``# Return the resultant GCD``    ``return` `getGCD` `# Function to sort an array by``# increasing order of GCD of``# digits of array elements``def` `sortArrayByGCD(arr):` `    ``# Sort the array``    ``arr.sort()` `    ``# Sort the array according to gcd of``    ``# digits using comparator function``    ``arr ``=` `sorted``(arr, key ``=` `keyFunc)` `    ``# Print the resultant array``    ``print``(``*``arr)` `# Driver Code``    ` `# Given array``arr ``=` `[``555``, ``363``, ``488``, ``244``]``sortArrayByGCD(arr)`

## Javascript

 ``
Output:
`244 363 488 555`

Time Complexity: O(N * log 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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up