Count of valid pairs (X, Y) from given strings such that concatenating X with itself yields Y

Given an array arr[] of N strings. Let X and Y be two strings, X and Y are said to be valid pair if the rearrangement of the resultant string from the concatenation of X with X (i.e., X+X) gives Y. The task is to count the number of such valid pairs.

Examples:

Input: N = 4, arr[] = {“hacker”, ”ackerhackerh”, ”int”, ”iittnn”, ”long”}
Output:
Explanation:
Pair {“hacker”, ”ackerhackerh”} “hacker” When concatenated with “hacker” gives ”ackerhackerh” after rearrangement.
Pair {“int”, ”iittnn”} “int” When concatenated with “int” gives ”iittnn” after rearrangement. 

Input: N = 3, arr[] = {“easy”, ”yeasseay“, “medium“} 
Output:1
Explanation:
Pair {“easy”, ”yeasseay“} “easy” When concatenated with “easy” gives ”yeasseay“ after rearrangement.

Naive Approach: The idea is to generate all possible pairs and check if any pairs form a valid pair as per the given condition or not. If yes then count this pair and check for the next pair. Print the value of count after the above steps.



Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: The idea is to store the sorted string in Hashmap along with its count and iterate through each string of the array concatenate it with itself and find its count in Hashmap add it to the count of pairs. Below are the steps:

  1. Create a hashmap.
  2. Sort the given strings in the array and store its count in hashmap.
  3. Again iterate through all strings and concatenate each string with itself sort the string and find its count in Hashmap.
  4. Update the final count in the above step and print the final count after all the above steps.

Below is the implementation of the above approach:

C++14

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++14 program for the above approach
#include<bits/stdc++.h>
using namespace std;
 
// Function to implement sorting on
// strings
string sorted(string s)
{
     
    // Convert string to char array
    char ch[s.length()];
    for(int i = 0; i < s.length(); i++)
    {
        ch[i] = s[i];
    }
     
    // Sort the array
    sort(ch, ch + s.length());
    string sb;
     
    for(char c : ch)
      sb += c;
 
    // Return string
     return sb;
}
 
// Function that count total number
// of valid pairs
int countPairs(string arr[], int N)
{
     
    // Create hashmap to store the
    // frequency of each string
    // in sorted form
    map<string, int> mp;
     
    // Initialise the count of pairs
    int count = 0;
     
    for(int i = 0; i < N; i++)
    {
        // Store each string in sorted
        // form along with it's count
        string s = sorted(arr[i]);
        mp[s]++;
    }
     
    // Iterate through each string
    // in the array
    for(int i = 0; i < N; i++)
    {
     
        // Concatenate each string with itself
        arr[i] = arr[i] + arr[i];
        sorted(arr[i]);
         
        // Find its count in the hashmap
        count += mp[sorted(arr[i])];
    }
     
    // Return answer
    return count;
}
 
// Driver Code
int main()
{
    int N = 3;
     
    // Given array of strings
    string arr[] = { "easy", "yeasseay",
                     "medium" };
     
    // Function Call
    cout << countPairs(arr, N) << endl;
    return 0;
}
 
// This code is contributed by sallagondaavinashreddy7

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
import java.util.*;
public class Main {
 
    // Function that count total number
    // of valid pairs
    public static int
    countPairs(String arr[], int N)
    {
 
        // Create hashmap to store the
        // frequency of each string
        // in sorted form
        HashMap<String, Integer> map
            = new HashMap<>();
 
        // Initialise the count of pairs
        int count = 0;
        for (int i = 0; i < N; i++) {
            String s = sort(arr[i]);
 
            // Store each string in sorted
            // form along with it's count
            map.put(s, map.getOrDefault(s, 0) + 1);
        }
 
        // Iterate through each string
        // in the array
        for (int i = 0; i < N; i++) {
 
            // Concatenate each string with itself
            String s = sort(arr[i] + arr[i]);
 
            // Find its count in the hashmap
            count += map.getOrDefault(s, 0);
        }
 
        // Return answer
        return count;
    }
 
    // Function to implement sorting on
    // strings
    public static String sort(String s)
    {
 
        // Convert string to char array
        char ch[] = s.toCharArray();
 
        // Sort the array
        Arrays.sort(ch);
        StringBuffer sb = new StringBuffer();
        for (char c : ch)
            sb.append(c);
 
        // Return string
        return sb.toString();
    }
 
    // Driver Code
    public static void main(String args[])
    {
        int N = 3;
 
        // Given array of strings
        String arr[] = { "easy", "yeasseay",
                        "medium" };
 
        // Function Call
        System.out.println(countPairs(arr, N));
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach
from collections import defaultdict
 
# Function that count total number
# of valid pairs
def countPairs(arr, N):
 
    # Create hashmap to store the
    # frequency of each string
    # in sorted form
    map = defaultdict(lambda : 0)
 
    # Initialise the count of pairs
    count = 0
    for i in range(N):
        s = sorted(arr[i])
 
        # Store each string in sorted
        # form along with it's count
        map["".join(s)] += 1
 
    # Iterate through each string
    # in the array
    for i in range(N):
 
        # Concatenate each string with itself
        s = sorted(arr[i] + arr[i])
 
        # Find its count in the hashmap
        count += map["".join(s)]
 
    # Return answer
    return count
 
# Driver Code
N = 3
 
# Given array of strings
arr = [ "easy", "yeasseay", "medium" ]
 
# Function call
print(countPairs(arr, N))
 
# This code is contributed by Shivam Singh

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
using System.Collections.Generic;
using System.Text;
 
class GFG{
 
// Function that count total number
// of valid pairs
public static int countPairs(string []arr, int N)
{
     
    // Create hashmap to store the
    // frequency of each string
    // in sorted form
    Dictionary<string,
               int> map = new Dictionary<string,
                                         int>();
 
    // Initialise the count of pairs
    int count = 0;
    for(int i = 0; i < N; i++)
    {
        string s = sort(arr[i]);
 
        // Store each string in sorted
        // form along with it's count
        if (map.ContainsKey(s))
        {
            map[s]++;
        }
        else
        {
            map[s] = 1;
        }
    }
 
    // Iterate through each string
    // in the array
    for(int i = 0; i < N; i++)
    {
         
        // Concatenate each string with itself
        string s = sort(arr[i] + arr[i]);
 
        // Find its count in the hashmap
        count += map.GetValueOrDefault(s, 0);
    }
 
    // Return answer
    return count;
}
 
// Function to implement sorting on
// strings
public static string sort(string s)
{
 
    // Convert string to char array
    char []ch = s.ToCharArray();
 
    // Sort the array
    Array.Sort(ch);
     
    StringBuilder sb = new StringBuilder();
    foreach(char c in ch)
        sb.Append(c);
 
    // Return string
    return sb.ToString();
}
 
// Driver Code
public static void Main(string []args)
{
    int N = 3;
 
    // Given array of strings
    string []arr = { "easy", "yeasseay",
                     "medium" };
 
    // Function call
    Console.Write(countPairs(arr, N));
}
}
 
// This code is contributed by rutvik_56

chevron_right


Output: 

1



 

Time Complexity: O(N)
Auxiliary Space: O(N)

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.




My Personal Notes arrow_drop_up

Recommended Posts:


Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.