Related Articles
Count new pairs of strings that can be obtained by swapping first characters of pairs of strings from given array
• Last Updated : 27 Apr, 2021

Given an array arr[] consisting of N strings, the task is to find the pair of strings that is not present in the array formed by any pairs (arr[i], arr[j]) by swapping the first characters of the strings arr[i] and arr[j].

Examples:

Input: arr[] = {“good”, “bad”, “food”}
Output: 2
Explanation:
The possible pairs that can be formed by swapping the first characters of any pair are:

1. (“good”, “bad”): Swapping the characters ‘g’ and ‘b’, modifies the strings to “bood” and gad which is not present in the array.
2. (“bad”, “food”): Swapping the characters ‘g’ and ‘b’, modifies the strings to “bood” and gad which is not present in the array.

Therefore, the total count is 2.

Input: arr[] = {“geek”, “peek”}
Output: 0

Naive Approach: The simplest approach to solve the given problem is to generate all the pairs of strings and for each pair swap the first characters of both the strings and if both the strings are present in the array then count this pair. After checking for all the pairs, print the value of the count obtained.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to count new pairs of strings``// that can be obtained by swapping first``// characters of any pair of strings``void` `countStringPairs(string a[], ``int` `n)``{` `    ``// Stores the count of pairs``    ``int` `ans = 0;` `    ``// Generate all possible pairs of``    ``// strings from the array arr[]``    ``for` `(``int` `i = 0; i < n; i++) {``        ``for` `(``int` `j = i + 1; j < n; j++) {` `            ``// Stores the current``            ``// pair of strings``            ``string p = a[i], q = a[j];` `            ``// Swap the first characters``            ``if` `(p != q) {` `                ``swap(p, q);``                ``int` `flag1 = 0;``                ``int` `flag2 = 0;` `                ``// Check if they are already``                ``// present in the array or not``                ``for` `(``int` `k = 0; k < n; k++) {` `                    ``if` `(a[k] == p) {``                        ``flag1 = 1;``                    ``}``                    ``if` `(a[k] == q) {``                        ``flag2 = 1;``                    ``}``                ``}` `                ``// If both the strings``                ``// are not present``                ``if` `(flag1 == 0 && flag2 == 0) {` `                    ``// Increment the ans``                    ``// by 1``                    ``ans = ans + 1;``                ``}``            ``}``        ``}``    ``}` `    ``// Print the resultant count``    ``cout << ans;``}` `// Driver Code``int` `main()``{``    ``string arr[] = { ``"good"``, ``"bad"``, ``"food"` `};``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``countStringPairs(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `GFG{` `// Function to count new pairs of strings``// that can be obtained by swapping first``// characters of any pair of strings``static` `void` `countStringPairs(String a[], ``int` `n)``{``    ` `    ``// Stores the count of pairs``    ``int` `ans = ``0``;` `    ``// Generate all possible pairs of``    ``// strings from the array arr[]``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ``for``(``int` `j = i + ``1``; j < n; j++)``        ``{``            ` `            ``// Stores the current``            ``// pair of strings``            ``char` `p[] = a[i].toCharArray();``            ``char` `q[] = a[j].toCharArray();` `            ``// Swap the first characters``            ``if` `(p[``0``] != q[``0``])``            ``{``                ``char` `temp = p[``0``];``                ``p[``0``] = q[``0``];``                ``q[``0``] = temp;``                ``int` `flag1 = ``0``;``                ``int` `flag2 = ``0``;` `                ``// Check if they are already``                ``// present in the array or not``                ``for``(``int` `k = ``0``; k < n; k++)``                ``{``                    ``if` `(a[k].equals(``new` `String(p)))``                    ``{``                        ``flag1 = ``1``;``                    ``}``                    ``if` `(a[k].equals(``new` `String(q)))``                    ``{``                        ``flag2 = ``1``;``                    ``}``                ``}` `                ``// If both the strings``                ``// are not present``                ``if` `(flag1 == ``0` `&& flag2 == ``0``)``                ``{` `                    ``// Increment the ans``                    ``// by 1``                    ``ans = ans + ``1``;``                ``}``            ``}``        ``}``    ``}` `    ``// Print the resultant count``    ``System.out.println(ans);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``String arr[] = { ``"good"``, ``"bad"``, ``"food"` `};``    ``int` `N = arr.length;``    ` `    ``countStringPairs(arr, N);``}``}` `// This code is contributed by Kingash`

## Python3

 `# python 3 program for the above approach` `# Function to count new pairs of strings``# that can be obtained by swapping first``# characters of any pair of strings``def` `countStringPairs(a, n):``  ` `    ``# Stores the count of pairs``    ``ans ``=` `0` `    ``# Generate all possible pairs of``    ``# strings from the array arr[]``    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(i ``+` `1``, n, ``1``):``          ` `            ``# Stores the current``            ``# pair of strings``            ``p ``=` `a[i]``            ``q ``=` `a[j]` `            ``# Swap the first characters``            ``if` `(p[``0``] !``=` `q[``0``]):``                ``p ``=` `list``(p)``                ``q ``=` `list``(q)``                ``temp ``=` `p[``0``]``                ``p[``0``] ``=` `q[``0``]``                ``q[``0``] ``=` `temp` `                ``p ``=` `''.join(p)``                ``q ``=` `''.join(q)``                ``flag1 ``=` `0``                ``flag2 ``=` `0` `                ``# Check if they are already``                ``# present in the array or not``                ``for` `k ``in` `range``(n):``                    ``if` `(a[k] ``=``=` `p):``                        ``flag1 ``=` `1``                    ``if` `(a[k] ``=``=` `q):``                        ``flag2 ``=` `1` `                ``# If both the strings``                ``# are not present``                ``if` `(flag1 ``=``=` `0` `and` `flag2 ``=``=` `0``):``                  ` `                    ``# Increment the ans``                    ``# by 1``                    ``ans ``=` `ans ``+` `1` `    ``# Print the resultant count``    ``print``(ans)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``"good"``, ``"bad"``, ``"food"``]``    ``N ``=` `len``(arr)``    ``countStringPairs(arr, N)` `    ``# This code is contributed by SURENDRA_GANGWAR.`

## C#

 `// C # program for the above approach``using` `System;``class` `GFG {` `    ``// Function to count new pairs of strings``    ``// that can be obtained by swapping first``    ``// characters of any pair of strings``    ``static` `void` `countStringPairs(``string``[] a, ``int` `n)``    ``{` `        ``// Stores the count of pairs``        ``int` `ans = 0;` `        ``// Generate all possible pairs of``        ``// strings from the array arr[]``        ``for` `(``int` `i = 0; i < n; i++) {``            ``for` `(``int` `j = i + 1; j < n; j++) {` `                ``// Stores the current``                ``// pair of strings``                ``char``[] p = a[i].ToCharArray();``                ``char``[] q = a[j].ToCharArray();` `                ``// Swap the first characters``                ``if` `(p != q) {``                    ``char` `temp = p;``                    ``p = q;``                    ``q = temp;``                    ``int` `flag1 = 0;``                    ``int` `flag2 = 0;` `                    ``// Check if they are already``                    ``// present in the array or not``                    ``for` `(``int` `k = 0; k < n; k++) {``                        ``if` `(a[k].Equals(``new` `string``(p))) {``                            ``flag1 = 1;``                        ``}``                        ``if` `(a[k].Equals(``new` `string``(q))) {``                            ``flag2 = 1;``                        ``}``                    ``}` `                    ``// If both the strings``                    ``// are not present``                    ``if` `(flag1 == 0 && flag2 == 0) {` `                        ``// Increment the ans``                        ``// by 1``                        ``ans = ans + 1;``                    ``}``                ``}``            ``}``        ``}` `        ``// Print the resultant count``        ``Console.WriteLine(ans);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``string``[] arr = { ``"good"``, ``"bad"``, ``"food"` `};``        ``int` `N = arr.Length;` `        ``countStringPairs(arr, N);``    ``}``}` `// This code is contributed by ukasp.`
Output:
`2`

Time Complexity: O(N3
Auxiliary Space: O(M), where M is the largest size of the string present in the array, A[]

Efficient Approach: The above approach can also be optimized by using the concept of Hashing. Follow the steps below to solve the problem:

• Initialize a variable, say ans as 0 to store the possible count of pairs of strings.
• Initialize a HashMap, say M to store all the strings present in the array arr[].
• Traverse the array, arr[] and increment the occurrence of arr[i] in M.
• Iterate in the range [0, N – 1] using the variable i and perform the following steps:
• After completing the above steps, print the value of ans as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to count newly created pairs``// by swapping the first characters of``// any pairs of strings``void` `countStringPairs(string a[], ``int` `n)``{` `    ``// Stores the count all possible``    ``// pair of strings``    ``int` `ans = 0;` `    ``// Push all the strings``    ``// into the Unordered Map``    ``unordered_map s;``    ``for` `(``int` `i = 0; i < n; i++) {``        ``s[a[i]]++;``    ``}` `    ``// Generate all possible pairs of``    ``// strings from the array arr[]``    ``for` `(``int` `i = 0; i < n; i++) {``        ``for` `(``int` `j = i + 1; j < n; j++) {` `            ``// Store the current``            ``// pair of strings``            ``string p = a[i];``            ``string q = a[j];` `            ``// Swap the first character``            ``if` `(p != q) {``                ``swap(p, q);` `                ``// Check if both string``                ``// are not present in map``                ``if` `(s.find(p) == s.end()``                    ``&& s.find(q) == s.end()) {``                    ``ans++;``                ``}``            ``}``        ``}``    ``}` `    ``// Print the result``    ``cout << ans;``}` `// Driver Code``int` `main()``{``    ``string arr[] = { ``"good"``, ``"bad"``, ``"food"` `};``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``countStringPairs(arr, N);` `    ``return` `0;``}`

## Python3

 `# Python3 program for the above approach` `# Function to count newly created pairs``# by swapping the first characters of``# any pairs of strings``def` `countStringPairs(a, n):` `    ``# Stores the count all possible``    ``# pair of strings``    ``ans ``=` `0` `    ``# Push all the strings``    ``# into the Unordered Map``    ``s ``=` `{}``    ``for` `i ``in` `range``(n):``        ``s[a[i]] ``=` `s.get(a[i], ``0``) ``+` `1` `    ``# Generate all possible pairs of``    ``# strings from the array arr[]``    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(i ``+` `1``, n):``            ` `            ``# Store the current``            ``# pair of strings``            ``p ``=` `[i ``for` `i ``in` `a[i]]``            ``q ``=` `[j ``for` `j ``in` `a[j]]` `            ``# Swap the first character``            ``if` `(p[``0``] !``=` `q[``0``]):``                ``p[``0``], q[``0``] ``=` `q[``0``], p[``0``]``                ` `                ``# Check if both string``                ``# are not present in map``                ``if` `(("".join(p) ``not` `in` `s) ``and``                    ``("".join(q) ``not` `in` `s)):``                    ``ans ``+``=` `1``                    ` `    ``# Print the result``    ``print` `(ans)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``"good"``, ``"bad"``, ``"food"` `]``    ``N ``=` `len``(arr)``    ` `    ``countStringPairs(arr, N)` `# This code is contributed by mohit kumar 29`
Output:
`2`

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

My Personal Notes arrow_drop_up