Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Check if given strings can be made same by swapping two characters of same or different strings

  • Last Updated : 03 May, 2021

Given an array of equal-length strings, arr[] of size N, the task is to check if all the strings can be made equal by repeatedly swapping any pair of characters of same or different strings from the given array. If found to be true, then print “YES”. Otherwise, print “NO”.

Examples:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = { “acbdd”, “abcee” } 
Output: YES 
Explanation: 
Swapping arr[0][1] and arr[0][2] modifies arr[] to { “abcdd”, “abcee” } 
Swapping arr[0][3] and arr[1][4] modifies arr[] to { “abced”, “abced” } 
Therefore, the required output is “YES”.



Input: arr[] = { “abb”, “acc”, “abc” } 
Output: YES 
Explanation: 
Swapping arr[0][2] with arr[1][1] modifies arr[] to { “abc”, “abc”, “abc” }. 
Therefore, the required output is “YES”.

Approach: The idea is to count the frequency of each distinct character of all the strings and check if the frequency of each distinct character is divisible by N or not. If found to be true, then print “YES”. Otherwise, print “NO”. Follow the steps below to solve the problem:

  • Initialize an array, say cntFreq[], to store the frequency of each distinct character of all the strings.
  • Traverse the array and for every string encountered, count the frequency of each distinct character of the string.
  • Traverse the array cntFreq[] using variable i. For every ith character, check if cntFreq[i] is divisible by N or not. If found to be false, then print “NO”.
  • Otherwise, print “YES”.

Below is the implementation of the above approach:

C++




// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if all strings can be
// made equal by swapping any pair of
// characters from the same or different strings
bool isEqualStrings(string arr[], int N)
{
    // Stores length of string
    int M = arr[0].length();
 
    // Store frequency of each distinct
    // character of the strings
    int cntFreq[256] = { 0 };
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        // Iterate over the characters
        for (int j = 0; j < M; j++) {
 
            // Update frequency
            // of arr[i][j]
            cntFreq[arr[i][j] - 'a']++;
        }
    }
 
    // Traverse the array cntFreq[]
    for (int i = 0; i < 256; i++) {
 
        // If cntFreq[i] is
        // divisible by N or not
        if (cntFreq[i] % N != 0) {
 
            return false;
        }
    }
 
    return true;
}
 
// Driver Code
int main()
{
    string arr[] = { "aab", "bbc", "cca" };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    if (isEqualStrings(arr, N)) {
 
        cout << "YES";
    }
    else {
 
        cout << "NO";
    }
 
    return 0;
}
Java



// Java program to implement
// the above approach 
class GFG{
    
// Function to check if all strings can be
// made equal by swapping any pair of
// characters from the same or different strings
static boolean isEqualStrings(String[] arr, int N)
{
     
    // Stores length of string
    int M = arr[0].length();
  
    // Store frequency of each distinct
    // character of the strings
    int[] cntFreq = new int[256];
    for(int i = 0; i < N; i++)
    {
        cntFreq[i] = 0;
    }
     
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
         
        // Iterate over the characters
        for(int j = 0; j < M; j++)
        {
             
            // Update frequency
            // of arr[i].charAt(j)
            cntFreq[arr[i].charAt(j) - 'a'] += 1;
        }
    }
  
    // Traverse the array cntFreq[]
    for(int i = 0; i < 256; i++)
    {
         
        // If cntFreq[i] is
        // divisible by N or not
        if (cntFreq[i] % N != 0)
        {
            return false;
        }
    }
    return true;
}
    
// Driver Code
public static void main(String[] args)
{
    String[] arr = { "aab", "bbc", "cca" };
    int N = arr.length;
     
    // Function Call
    if (isEqualStrings(arr, N))
    {
        System.out.println("YES");
    }
    else
    {
        System.out.println("NO");
    }
}
}
 
// This code is contributed by AnkThon
Python3



# Python3 program to implement
# the above approach
 
# Function to check if all strings can
# be made equal by swapping any pair of
# characters from the same or different
# strings
def isEqualStrings(arr, N):
 
    # Stores length of string
    M = len(arr[0])
 
    # Store frequency of each distinct
    # character of the strings
    cntFreq = [0] * 256
 
    # Traverse the array
    for i in range(N):
 
        # Iterate over the characters
        for j in range(M): 
             
            # Update frequency
            # of arr[i][j]
            cntFreq[ord(arr[i][j]) - ord('a')] += 1
             
    # Traverse the array cntFreq[]
    for i in range(256):
         
        # If cntFreq[i] is
        # divisible by N or not
        if (cntFreq[i] % N != 0):
            return False
         
    return True
 
# Driver Code
if __name__ == "__main__" :
     
    arr = [ "aab", "bbc", "cca" ]
    N = len(arr)
 
    # Function Call
    if isEqualStrings(arr, N):
        print("YES")
    else:
        print("NO")
     
# This code is contributed by jana_sayantan
C#



// C# program to implement
// the above approach 
using System;
    
class GFG{
    
// Function to check if all strings can be
// made equal by swapping any pair of
// characters from the same or different strings
static bool isEqualStrings(string[] arr, int N)
{
     
    // Stores length of string
    int M = arr[0].Length;
  
    // Store frequency of each distinct
    // character of the strings
    int[] cntFreq = new int[256];
    for(int i = 0; i < N; i++)
    {
        cntFreq[i] = 0;
    }
     
    // Traverse the array
    for(int i = 0; i < N; i++)
    {
         
        // Iterate over the characters
        for(int j = 0; j < M; j++)
        {
             
            // Update frequency
            // of arr[i][j]
            cntFreq[arr[i][j] - 'a'] += 1;
        }
    }
  
    // Traverse the array cntFreq[]
    for(int i = 0; i < 256; i++)
    {
         
        // If cntFreq[i] is
        // divisible by N or not
        if (cntFreq[i] % N != 0)
        {
            return false;
        }
    }
    return true;
}
    
// Driver Code
public static void Main()
{
    string[] arr = { "aab", "bbc", "cca" };
    int N = arr.Length;
  
    // Function Call
    if (isEqualStrings(arr, N))
    {
        Console.WriteLine("YES");
    }
    else
    {
        Console.WriteLine("NO");
    }
}
}
 
// This code is contributed by susmitakundugoaldanga
Javascript



<script>
 
// javascript program of the above approach
 
// Function to check if all strings can be
// made equal by swapping any pair of
// characters from the same or different strings
function isEqualStrings(arr, N)
{
     
    // Stores length of string
    let M = arr[0].length;
  
    // Store frequency of each distinct
    // character of the strings
    let cntFreq = new Array(256).fill(0);
    for(let i = 0; i < N; i++)
    {
        cntFreq[i] = 0;
    }
     
    // Traverse the array
    for(let i = 0; i < N; i++)
    {
         
        // Iterate over the characters
        for(let j = 0; j < M; j++)
        {
             
            // Update frequency
            // of arr[i].charAt(j)
            cntFreq[arr[i][j] - 'a'] += 1;
        }
    }
  
    // Traverse the array cntFreq[]
    for(let i = 0; i < 256; i++)
    {
         
        // If cntFreq[i] is
        // divisible by N or not
        if (cntFreq[i] % N != 0)
        {
            return false;
        }
    }
    return true;
}
 
    // Driver Code
     
    let arr = [ "aab", "bbc", "cca" ];
    let N = arr.length;
     
    // Function Call
    if (isEqualStrings(arr, N))
    {
        document.write("YES");
    }
    else
    {
        document.write("NO");
    }
 
// This code is contributed by target_2.
</script>
Output: 
YES
 
Time Complexity: O(N * M + 256), where M is the length of the string 
Auxiliary Space: O(256)



My Personal Notes
arrow_drop_up
Next

Minimize cost to empty given array where cost of removing an element is its absolute difference with Time instant
Recommended Articles
Page :
Check if two binary strings can be made equal by swapping pairs of unequal characters
20, Jan 21
Check if two strings can be made equal by swapping pairs of adjacent characters
03, Feb 21
Check if a string can be made palindromic by swapping pairs of characters from indices having unequal characters in a Binary String
31, Mar 21
Check if two strings can be made equal by swapping one character among each other
20, Nov 19
Check if two binary strings can be made equal by swapping 1s occurring before 0s
18, Jan 21
Check if a string can be made equal to another string by swapping or replacement of characters
24, Jan 21
Check if two arrays can be made equal by swapping pairs of one of the arrays
03, Feb 21
Longest Substring that can be made a palindrome by swapping of characters
25, Dec 20
Check if all strings of an array can be made same by interchanging characters
15, Sep 20
Count new pairs of strings that can be obtained by swapping first characters of pairs of strings from given array
14, Apr 21
Check whether two strings can be made equal by copying their characters with the adjacent ones
09, Oct 19
Minimize replacements or swapping of same indexed characters required to make two given strings palindromic
03, Nov 20
Check whether two strings can be made equal by reversing substring of equal length from both strings
15, Jul 20
Check if two strings can be made equal by reversing a substring of one of the strings
09, Dec 20
Count different Bitwise OR values of equal length strings S1 and S2 by swapping exactly one pair of characters from the first string
27, Jun 21
Check if a string can be converted to another by swapping of adjacent characters of given type
01, Sep 20
Check if an array of pairs can be sorted by swapping pairs with different first elements
29, Apr 21
Check if all bits can be made same by flipping two consecutive bits
09, Jan 20
Python Program to check if two sentences can be made the same by rearranging the words
23, Feb 21
Check if permutation of a given string can be made palindromic by removing at most K characters
25, Oct 20
Count N-length arrays made from first M natural numbers whose subarrays can be made palindromic by replacing less than half of its elements
16, Dec 20
Check whether two strings can be made equal by increasing prefixes
11, Nov 18
Check if a string can be split into two strings with same number of K-frequent characters
08, Jul 20
Check whether two strings contain same characters in same order
31, May 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
nk14646
@nk14646
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!