 GFG App
Open App Browser
Continue

# Count equal pairs from given string arrays

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, s2) or (s1, s2)
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 ` `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 ` `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 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 mp = ``new` `HashMap(); `   `        ``// 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 mp = ``new` `Dictionary(); `   `        ``// 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

 ``

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)

My Personal Notes arrow_drop_up