Open In App

Count equal pairs from given string arrays

Improve
Improve
Like Article
Like
Save
Share
Report

Given two string arrays s1[] and s2[]. The task is to find the count of pairs (s1[i], s2[j]) such that s1[i] = s2[j]. Note that an element s1[i] can only participate in a single pair.

Examples: 

Input: s1[] = {“abc”, “def”}, s2[] = {“abc”, “abc”} 
Output:
Explanation: Only valid pair is (s1[0], s2[0]) or (s1[0], s2[1]) 
Note that even though “abc” appears twice in the 
array s2[] but it can only make a single pair 
as “abc” only appears once in the array s1[]

Input: s1[] = {“aaa”, “aaa”}, s2[] = {“aaa”, “aaa”} 
Output:

Naive approach:

Generate all the pairs and check for the given condition, if it satisfy then increment the count by 1.

  • Initialise a variable count = 0
  • Generate all the pair
    • Check if this pair is already considered, then continue
    • Check if the pair satisfies the given condition
      • Replace the string in s2 with “-1”, just to mark that we have considered this string with some pair
      • Increment the count by 1
  • Return the count

Below is the implementation of the above approach:

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the count of required pairs
int count_pairs(string s1[], string s2[], int n1, int n2)
{
 
    // Initialise a variable count = 0
    int count = 0;
 
    // Generate all the pair
    for (int i = 0; i < n1; i++) {
        for (int j = 0; j < n2; j++) {
 
            // Check if this pair is already considered
            // if true, then continue
            if (s2[j] == "-1")
                continue;
 
            // Check if pair satisfy the given condition
            if (s1[i] == s2[j]) {
 
                // Replace the string in s2 with -1, just to
                // mark that we have consider this string
                // with some pair
                s2[j] = "-1";
 
                // Increment the count by 1
                count++;
                break;
            }
        }
    }
 
    // Return the count
    return count;
}
 
// Driver code
int main()
{
    string s1[] = { "abc", "def", "abc" };
    string s2[] = { "abc", "abc" };
    int n1 = sizeof(s1) / sizeof(string);
    int n2 = sizeof(s2) / sizeof(string);
 
    cout << count_pairs(s1, s2, n1, n2);
 
    return 0;
}


Java




import java.util.Arrays;
 
public class Gfg {
    // Function to return the count of required pairs
    public static int count_pairs(String s1[], String s2[],
                                  int n1, int n2)
    {
 
        // Initialise a variable count = 0
        int count = 0;
 
        // Generate all the pair
        for (int i = 0; i < n1; i++) {
            for (int j = 0; j < n2; j++) {
 
                // Check if this pair is already considered
                // if true, then continue
                if (s2[j] == "-1")
                    continue;
 
                // Check if pair satisfy the given condition
                if (s1[i].equals(s2[j])) {
 
                    // Replace the string in s2 with -1,
                    // just to mark that we have consider
                    // this string with some pair
                    s2[j] = "-1";
 
                    // Increment the count by 1
                    count++;
                    break;
                }
            }
        }
 
        // Return the count
        return count;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        String s1[] = { "abc", "def", "abc" };
        String s2[] = { "abc", "abc" };
        int n1 = s1.length;
        int n2 = s2.length;
 
        System.out.println(count_pairs(s1, s2, n1, n2));
    }
}


Python3




# Python implementation of the approach
 
# Function to return the count of required pairs
def count_pairs( s1,  s2, n1, n2):
    # Initialise a variable count = 0
    count = 0;
 
    # Generate all the pair
    for i in range(0,n1):
        for j in range(0,n2):
 
            # Check if this pair is already considered
            # if true, then continue
            if (s2[j] == "-1"):
                continue;
 
            # Check if pair satisfy the given condition
            if (s1[i] == s2[j]) :
 
                # Replace the string in s2 with -1, just to
                # mark that we have consider this string
                # with some pair
                s2[j] = "-1";
 
                # Increment the count by 1
                count+=1;
                break;
             
 
    # Return the count
    return count;
 
# Driver code
s1 = [ "abc", "def", "abc" ];
s2 = [ "abc", "abc" ];
n1 = len(s1);
n2 = len(s2);
 
print(count_pairs(s1, s2, n1, n2));
 
 # This code is contributed by ratiagrawal.


C#




// C# code to implement the above idea
using System;
using System.Collections.Generic;
 
class GFG {
 
  static int count_pairs(string[] s1, string[] s2, int n1, int n2)
  {
 
    // Initialise a variable count = 0
    int count = 0;
 
    // Generate all the pair
    for (int i = 0; i < n1; i++) {
      for (int j = 0; j < n2; j++) {
 
        // Check if this pair is already considered
        // if true, then continue
        if (s2[j] == "-1")
          continue;
 
        // Check if pair satisfy the given condition
        if (s1[i] == s2[j]) {
 
          // Replace the string in s2 with -1, just to
          // mark that we have consider this string
          // with some pair
          s2[j] = "-1";
 
          // Increment the count by 1
          count++;
          break;
        }
      }
    }
 
    // Return the count
    return count;
  }
 
  // Driver code
  public static void Main()
  {
    string[] s1 = { "abc", "def", "abc" };
    string[] s2 = { "abc", "abc" };
    int n1 = s1.Length;
    int n2 = s2.Length;
 
    Console.Write(count_pairs(s1, s2, n1, n2));
  }
}
 
// This code is contributed by poojaagarwal2.


Javascript




// Javascript implementation of the approach
 
// Function to return the count of required pairs
function count_pairs(s1, s2, n1, n2)
{
 
    // Initialise a variable count = 0
    let count = 0;
 
    // Generate all the pair
    for (let i = 0; i < n1; i++) {
        for (let j = 0; j < n2; j++) {
 
            // Check if this pair is already considered
            // if true, then continue
            if (s2[j] == "-1")
                continue;
 
            // Check if pair satisfy the given condition
            if (s1[i] == s2[j]) {
 
                // Replace the string in s2 with -1, just to
                // mark that we have consider this string
                // with some pair
                s2[j] = "-1";
 
                // Increment the count by 1
                count++;
                break;
            }
        }
    }
 
    // Return the count
    return count;
}
 
// Driver code
    let s1 = [ "abc", "def", "abc" ];
    let s2 = [ "abc", "abc" ];
    let n1 = s1.length;
    let n2 = s2.length;
 
    document.write(count_pairs(s1, s2, n1, n2));


Output

2

Time Complexity: O(n1*n2), Where n1 and n2 are the lengths of given string array s1 and s2 respectively.
Auxiliary Space: O(1)

Approach:  

  • Create an unordered_map to store the frequencies of all the strings of the array s1[].
  • Now for every string of the array, check whether a string equal to the current string is present in the map or not.
  • If yes then increment the count and decrement the frequency of the string from the map. This is because a string can only make a pair once.
  • Print the count in the end.

Below is the implementation of the above approach:  

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the count of required pairs
int count_pairs(string s1[], string s2[], int n1, int n2)
{
 
    // Map to store the frequencies of
    // all the strings of array s1[]
    unordered_map<string, int> mp;
 
    // Update the frequencies
    for (int i = 0; i < n1; i++)
        mp[s1[i]]++;
 
    // To store the count of pairs
    int cnt = 0;
 
    // For every string of array s2[]
    for (int i = 0; i < n2; i++) {
 
        // If current string can make a pair
        if (mp[s2[i]] > 0) {
 
            // Increment the count of pairs
            cnt++;
 
            // Decrement the frequency of the
            // string as once occurrence has been
            // used in the current pair
            mp[s2[i]]--;
        }
    }
 
    // Return the count
    return cnt;
}
 
// Driver code
int main()
{
    string s1[] = { "abc", "def" };
    string s2[] = { "abc", "abc" };
    int n1 = sizeof(s1) / sizeof(string);
    int n2 = sizeof(s2) / sizeof(string);
 
    cout << count_pairs(s1, s2, n1, n2);
 
    return 0;
}


Java




// Java implementation of the approach
import java.util.*;
 
class GFG
{
     
    // Function to return
    // the count of required pairs
    static int count_pairs(String s1[],
                           String s2[],
                           int n1, int n2)
    {
     
        // Map to store the frequencies of
        // all the strings of array s1[]
        HashMap<String,
                Integer> mp = new HashMap<String,
                                          Integer>();
 
        // Update the frequencies
        for (int i = 0; i < n1; i++)
            mp.put(s1[i], 0);
             
        // Update the frequencies
        for (int i = 0; i < n1; i++)
            mp.put(s1[i], mp.get(s1[i]) + 1);
     
        // To store the count of pairs
        int cnt = 0;
     
        // For every string of array s2[]
        for (int i = 0; i < n2; i++)
        {
     
            // If current string can make a pair
            if (mp.get(s2[i]) > 0)
            {
     
                // Increment the count of pairs
                cnt++;
     
                // Decrement the frequency of the
                // string as once occurrence has been
                // used in the current pair
                mp.put(s2[i], mp.get(s2[i]) - 1);
            }
        }
     
        // Return the count
        return cnt;
    }
     
    // Driver code
    public static void main (String[] args)
    {
        String s1[] = { "abc", "def" };
        String s2[] = { "abc", "abc" };
        int n1 = s1.length;
        int n2 = s2.length;
     
        System.out.println(count_pairs(s1, s2, n1, n2));
    }
}
 
// This code is contributed by AnkitRai01


Python3




# python 3 implementation of the approach
 
# Function to return the count of required pairs
def count_pairs(s1, s2,n1,n2):
    # Map to store the frequencies of
    # all the strings of array s1[]
    mp = {s1[i]:0 for i in range(len(s1))}
 
    # Update the frequencies
    for i in range(n1):
        mp[s1[i]] += 1
 
    # To store the count of pairs
    cnt = 0
 
    # For every string of array s2[]
    for i in range(n2):
        # If current string can make a pair
        if (mp[s2[i]] > 0):
            # Increment the count of pairs
            cnt += 1
 
            # Decrement the frequency of the
            # string as once occurrence has been
            # used in the current pair
            mp[s2[i]] -= 1
 
    # Return the count
    return cnt
 
# Driver code
if __name__ == '__main__':
    s1 = ["abc", "def"]
    s2 = ["abc", "abc"]
    n1 = len(s1)
    n2 = len(s2)
 
    print(count_pairs(s1, s2, n1, n2))
 
# This code is contributed by
# Surendra_Gangwar


C#




// C# implementation of the approach
using System;
using System.Collections.Generic;
 
class GFG
{
     
    // Function to return
    // the count of required pairs
    static int count_pairs(String []s1,
                           String []s2,
                           int n1, int n2)
    {
     
        // Map to store the frequencies of
        // all the strings of array s1[]
        Dictionary<String,
                   int> mp = new Dictionary<String,
                                            int>();
 
        // Update the frequencies
        for (int i = 0; i < n1; i++)
            mp.Add(s1[i], 0);
             
        // Update the frequencies
        for (int i = 0; i < n1; i++)
        {
            var v = mp[s1[i]] + 1;
            mp.Remove(s1[i]);
            mp.Add(s1[i], v);
        }
     
        // To store the count of pairs
        int cnt = 0;
     
        // For every string of array s2[]
        for (int i = 0; i < n2; i++)
        {
     
            // If current string can make a pair
            if (mp[s2[i]] > 0)
            {
     
                // Increment the count of pairs
                cnt++;
     
                // Decrement the frequency of the
                // string as once occurrence has been
                // used in the current pair
                if(mp.ContainsKey(s2[i]))
                {
                    var v = mp[s2[i]] - 1;
                    mp.Remove(s2[i]);
                    mp.Add(s2[i], v);
                }
                else
                    mp.Add(s2[i], mp[s2[i]] - 1);
            }
        }
     
        // Return the count
        return cnt;
    }
     
    // Driver code
    public static void Main (String[] args)
    {
        String []s1 = { "abc", "def" };
        String []s2 = { "abc", "abc" };
        int n1 = s1.Length;
        int n2 = s2.Length;
     
        Console.WriteLine(count_pairs(s1, s2, n1, n2));
    }
}
 
// This code is contributed by 29AjayKumar


Javascript




<script>
 
// Javascript implementation of the approach
 
// Function to return the count of required pairs
function count_pairs(s1, s2, n1, n2)
{
 
    // Map to store the frequencies of
    // all the strings of array s1[]
    var mp = new Map();
 
    // Update the frequencies
    for (var i = 0; i < n1; i++)
    {
        if(mp.has(s1[i]))
        {
            mp.set(s1[i], mp.get(s1[i])+1)
        }
        else
        {
            mp.set(s1[i], 1)
        }
    }
         
 
    // To store the count of pairs
    var cnt = 0;
 
    // For every string of array s2[]
    for (var i = 0; i < n2; i++) {
 
        // If current string can make a pair
        if (mp.get(s2[i]) > 0) {
 
            // Increment the count of pairs
            cnt++;
 
            // Decrement the frequency of the
            // string as once occurrence has been
            // used in the current pair
            mp.set(s2[i], mp.get(s2[i])-1)
        }
    }
 
    // Return the count
    return cnt;
}
 
// Driver code
var s1 = ["abc", "def" ];
var s2 = ["abc", "abc" ];
var n1 = s1.length;
var n2 = s2.length;
 
document.write( count_pairs(s1, s2, n1, n2));
 
</script>


Output

1

Time Complexity: O(n1+n2), Where n1 and n2 are the lengths of given string array s1 and s2 respectively.
Auxiliary Space: O(n1)



Last Updated : 03 Feb, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads