Skip to content
Related Articles

Related Articles

Improve Article

Generate string with Hamming Distance as half of the hamming distance between strings A and B

  • Last Updated : 13 Apr, 2020

Given two Binary string A and B of length N, the task is to find the Binary string whose Hamming Distance to strings A and B is half the Hamming Distance of A and B.

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.

Examples:



Input: A = “1001010”, B = “0101010”
Output: 0001010
Explanation:
The hamming distance of the string A and B is 2.
The hamming distance of the output string to A is 1.
The hamming distance of the output string to B is 1.

Input: A = “1001010”, B = “1101010”
Output: Not Possible
Explanation:
There exist no string which satisfy our condition.

Naive Approach: A naive approach is to generate all possible binary strings of the length N and the calculate the Hamming Distance of each string with A and B. If the Hamming Distance between the generated string and to the given string A and B is half the Hamming Distance between A and B, then the generated string is the resultant string. Else there is no such string exist.

Time Complexity: O(2N)

Efficient Approach:

  1. Find the Hamming Distance(say a) between the two given string A and B. If a is odd then we can’t generate another string with Hamming Distance (a/2) with the strings A and B.
  2. If a is even, then choose first (a/2) characters from string A which is not equal to string B and next (a/2) characters from string B which does not equal to string A to make the resulting string.
  3. Append the equal characters from string A and B to the resultant string.

Below is the implementation of the above approach:

C++




// C++ implementation of the above
// approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to find the required
// string
void findString(string A, string B)
{
    int dist = 0;
  
    // Find the hamming distance
    // between A and B
    for (int i = 0; A[i]; i++) {
        if (A[i] != B[i]) {
            dist++;
        }
    }
  
    // If distance is odd, then
    // resultant string is not
    // possible
    if (dist & 1) {
        cout << "Not Possible"
             << endl;
    }
  
    // Make the resultant string
    else {
  
        // To store the final
        // string
        string res = "";
  
        int K = dist / 2;
        // Pick k characters from
        // each string
  
        for (int i = 0; A[i]; i++) {
  
            // Pick K characters
            // from string B
            if (A[i] != B[i] && K > 0) {
                res.push_back(B[i]);
                K--;
            }
  
            // Pick K characters
            // from string A
            else if (A[i] != B[i]) {
                res.push_back(A[i]);
            }
  
            // Append the res characters
            // from string to the
            // resultant string
            else {
                res.push_back(A[i]);
            }
        }
  
        // Print the resultant
        // string
        cout << res << endl;
    }
}
  
// Driver's Code
int main()
{
    string A = "1001010";
    string B = "0101010";
  
    // Function to find the resultant
    // string
    findString(A, B);
    return 0;
}

Java




// Java implementation of the above 
// approach 
class GFG
{
  
    // Function to find the required 
    // string 
    static void findString(String A, String B) 
    
        int dist = 0
      
        // Find the hamming distance 
        // between A and B 
        for (int i = 0; i < A.length(); i++) 
        
            if(A.charAt(i) != B.charAt(i)) 
                dist++; 
        
      
        // If distance is odd, then 
        // resultant string is not 
        // possible 
        if((dist & 1) == 1
        
            System.out.println("Not Possible");
        
      
        // Make the resultant string 
        else 
        
      
            // To store the final 
            // string 
            String res = ""
      
            int K = (int)dist / 2
              
            // Pick k characters from 
            // each string 
            for (int i = 0; i < A.length(); i++) { 
      
                // Pick K characters 
                // from string B 
                if (A.charAt(i) != B.charAt(i) && K > 0) { 
                    res += B.charAt(i); 
                    K--; 
                
      
                // Pick K characters 
                // from string A 
                else if (A.charAt(i) != B.charAt(i)) { 
                    res += A.charAt(i); 
                
      
                // Append the res characters 
                // from string to the 
                // resultant string 
                else
                    res += A.charAt(i); 
                
            
      
            // Print the resultant 
            // string 
            System.out.println(res) ; 
        }
    }
      
    // Driver's Code 
    public static void main (String[] args)
    
        String A = "1001010"
        String B = "0101010"
      
        // Function to find the resultant 
        // string 
        findString(A, B); 
    
}
  
// This code is contributed by Yash_R

Python3




# Python3 implementation of the above 
# approach 
  
# Function to find the required 
# string 
def findString(A, B) : 
  
    dist = 0
  
    # Find the hamming distance 
    # between A and B 
    for i in range(len(A)) :
        if (A[i] != B[i]) :
            dist += 1
  
    # If distance is odd, then 
    # resultant string is not 
    # possible 
    if (dist & 1) :
        print("Not Possible");
  
    # Make the resultant string 
    else :
  
        # To store the final 
        # string 
        res = ""; 
  
        K = dist // 2;
          
        # Pick k characters from 
        # each string 
  
        for i in range(len(A)) :
  
            # Pick K characters 
            # from string B 
            if (A[i] != B[i] and K > 0) : 
                res += B[i]; 
                K -= 1
  
            # Pick K characters 
            # from string A 
            elif (A[i] != B[i]) : 
                res += A[i]; 
          
            # Append the res characters 
            # from string to the 
            # resultant string 
            else :
                res += A[i]; 
  
        # Print the resultant 
        # string 
        print(res); 
  
# Driver's Code 
if __name__ == "__main__"
  
    A = "1001010"
    B = "0101010"
  
    # Function to find the resultant 
    # string 
    findString(A, B); 
      
# This code is contributed by Yash_R

C#




// C# implementation of the above approach 
using System;
  
class GFG
{
  
    // Function to find the required 
    // string 
    static void findString(string A, string B) 
    
        int dist = 0; 
      
        // Find the hamming distance 
        // between A and B 
        for (int i = 0; i < A.Length; i++) 
        
            if(A[i] != B[i]) 
                dist++; 
        
      
        // If distance is odd, then 
        // resultant string is not 
        // possible 
        if((dist & 1) == 1) 
        
            Console.WriteLine("Not Possible");
        
      
        // Make the resultant string 
        else 
        
      
            // To store the final 
            // string 
            string res = ""
      
            int K = (int)dist / 2; 
              
            // Pick k characters from 
            // each string 
            for (int i = 0; i < A.Length; i++) { 
      
                // Pick K characters 
                // from string B 
                if (A[i] != B[i] && K > 0) { 
                    res += B[i]; 
                    K--; 
                
      
                // Pick K characters 
                // from string A 
                else if (A[i] != B[i]) { 
                    res += A[i]; 
                
      
                // Append the res characters 
                // from string to the 
                // resultant string 
                else
                    res += A[i]; 
                
            
      
            // Print the resultant 
            // string 
            Console.WriteLine(res) ; 
        }
    }
      
    // Driver's Code 
    public static void Main (string[] args)
    
        string A = "1001010"
        string B = "0101010"
      
        // Function to find the resultant 
        // string 
        findString(A, B); 
    
}
  
// This code is contributed by Yash_R
Output:
0001010

Time Complexity: O(N), where N is the length of the string.




My Personal Notes arrow_drop_up
Recommended Articles
Page :