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: 1
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: 2
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++ 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;
} |
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));
}
} |
# 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# 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 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));
|
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++ 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 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 |
# 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# 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 |
<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> |
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)