Sort an array in increasing order of GCD of their digits
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:
- 555: GCD(5, 5, 5) = 5.
- 363: GCD(3, 6, 3) = 3.
- 488: GCD(4, 8, 8) = 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++
#include<bits/stdc++.h>
using namespace std;
int gcd( int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
int keyFunc( int n)
{
int getGCD = 0;
while (n > 0)
{
getGCD = gcd(n % 10, getGCD);
if (getGCD == 1)
return 1;
n = n / 10;
}
return getGCD;
}
bool compare( int o1, int o2)
{
int x = keyFunc(o1);
int y = keyFunc(o2);
if (x == y)
{
return o1 < o2;
}
return x < y;
}
void sortArrayByGCD(vector< int >arr)
{
vector< int >list;
for ( int i : arr)
{
list.push_back(i);
}
sort(list.begin(), list.end(), compare);
for ( int i : list)
{
cout << i << " " ;
}
}
int main()
{
vector< int >arr = { 555, 363, 488, 244 };;
sortArrayByGCD(arr);
}
|
Java
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
class GFG{
static int gcd( int a, int b)
{
if (b == 0 )
return a;
return gcd(b, a % b);
}
static int keyFunc( int n)
{
int getGCD = 0 ;
while (n > 0 )
{
getGCD = gcd(n % 10 , getGCD);
if (getGCD == 1 )
return 1 ;
n = n / 10 ;
}
return getGCD;
}
public static void sortArrayByGCD( int [] arr)
{
ArrayList<Integer> list = new ArrayList<Integer>();
for ( int i : arr)
{
list.add(i);
}
Collections.sort(list, new Comparator<Integer>()
{
@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;
}
});
for ( int i : list)
{
System.out.print(i + " " );
}
}
public static void main(String[] args)
{
int arr[] = { 555 , 363 , 488 , 244 };
sortArrayByGCD(arr);
}
}
|
Python3
def gcd(a, b):
if not b:
return a
return gcd(b, a % b)
def keyFunc(n):
getGCD = int ( str (n)[ 0 ])
for i in str (n):
getGCD = gcd(getGCD, int (i))
return getGCD
def sortArrayByGCD(arr):
arr.sort()
arr = sorted (arr, key = keyFunc)
print ( * arr)
arr = [ 555 , 363 , 488 , 244 ]
sortArrayByGCD(arr)
|
C#
using System;
using System.Linq;
class GFG
{
static int Gcd( int a, int b)
{
if (b == 0)
return a;
return Gcd(b, a % b);
}
static int KeyFunc( int n)
{
int gcd = 0;
while (n > 0)
{
gcd = Gcd(n % 10, gcd);
if (gcd == 1)
return 1;
n /= 10;
}
return gcd;
}
static void SortArrayByGcd( int [] arr)
{
var list = arr.ToList();
list.Sort((o1, o2) =>
{
var x = KeyFunc(o1) - KeyFunc(o2);
if (x == 0)
{
if (o1 > o2)
x = 1;
else
x = -1;
}
return x;
});
Console.WriteLine( string .Join( " " , list));
}
static void Main( string [] args)
{
int [] arr = { 555, 363, 488, 244 };
SortArrayByGcd(arr);
}
}
|
Javascript
<script>
function gcd(a, b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
function keyFunc(n) {
let getGCD = String(n)[0]
for (let i = 0; i < n; i++)
getGCD = gcd(getGCD, i)
return getGCD
}
function sortArrayByGCD(arr) {
arr.sort()
arr = arr.sort(keyFunc)
for (let i of arr) {
document.write(i + " " )
}
}
let arr = [555, 363, 488, 244];
sortArrayByGCD(arr);
</script>
|
Time Complexity: O(N * log N)
Auxiliary Space: O(1)
Last Updated :
11 Jan, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...