Skip to content
Related Articles

Related Articles

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 mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :