Skip to content
Related Articles

Related Articles

Improve Article
Sort an array of strings by replacements with their GCD with elements from another array
  • Last Updated : 03 May, 2021

Given two arrays of strings arr[] and k[] of size N and M respectively, the task is to sort the array arr[] after replacing each array element arr[i] with the GCD of arr[i] and k[j], where 0 ≤ i < N and 0 ≤ j < M. If it is not possible to sort the array, then print -1.

Note: The GCD of two strings A and B is the smallest string, which when concatenated multiple times, becomes equal to A and B. If no such string exists, return an empty string.

Examples:

Input:  arr[] = { ‘geeks’, ‘for’, ‘geeks’ },  k[] = { ‘geeksgeeks’, ‘for’ }
Output:  { ‘ ‘, ‘for’, ‘geeks’ }
Explanation: 
arr[0] = GCD(‘geeks’, ‘for’) = ‘ ‘
arr[1] = GCD(‘for’, ‘for’) = ‘for’
arr[2] = GCD(‘geeks’, ‘geeksgeeks’) = ‘geeks’ 
arr[0] < arr[1] < arr[2]

Input:  arr[] = { ‘aacd’, ‘abdc’, ‘acac’, ‘aaaa’ },  k[] = {‘aa’, ‘ac’}
Output: -1



Approach: The given problem can be solved greedily. Follow the steps below to solve the problem:

Below is the implementation.

Python3




# Python implementation of the 
# above approach
  
# Function to find gcd of two numbers
def GCD(a, b):
    if(b == 0):
        return a
    else:
        return GCD(b, a % b)
  
  
# Function to find GCD of two strings 
def StringGCD(a, b):
      
    # Length of gcd of two strings
    gcd = GCD(len(a), len(b))
      
    if a[:gcd] == b[:gcd]:
        if a*(len(b)//gcd) == b*(len(a)//gcd):
            return a[:gcd]
      
    # GCD of strings does not exist
    return ' '
  
# Function to check if the array is
# sorted in increasing order or not
def isIncreasing(arr):
    
    for i in range(len(arr)-1):
        if arr[i] >= arr[i + 1]:
            return False
            
    return True
  
# Function to check if arr[] can
# be sorted in increasing order
def sortByGcd(arr, k):
    
      # Previous string
    prev = ''
      
    # Iterate through the array
    for i in range(len(arr)):
        
        # Initialize optimal
        # element by arr[i]
        optEle = arr[i]
          
        # Flag to find first
        # string > prev
        flag = True
          
        for idx in range(len(k)):
            
            # Gcd of two strings
            Ele = StringGCD(arr[i], k[idx])
              
            # If Ele > prev and flag is set
            if Ele > prev and flag:
                
                  # Update optEle
                optEle = Ele
                  
                # Update Flag
                flag = False
              
            # If Ele > prev
            if Ele > prev:
                    
                # Update optEle
                optEle = min(optEle, Ele)
                  
        # Update arr[i] by optEle
        arr[i] = optEle
          
        # Update prev by arr[i]
        prev = arr[i]
          
    # Check is arr[] is sorted in ascending order
    if isIncreasing(arr):
        return arr
        
    # Sorted order is not possible
    else:
        return -1
  
  
# Driver Code
  
arr = ['geeks', 'for', 'geeks']
k = ['geeks', 'for']
print(sortByGcd(arr, k))

Time Complexity: O(N * K * log(min(N, K))
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 :