Write Python Program to Find Uncommon Characters of the Two Strings

In this tutorial, we will write the Python program to find the uncommon character from the given two strings. The uncommon characters refer to that character is in one string or present in another string but not in both. The given strings are lowercase characters and can contain duplicates. Let's understand the following example.

Example -

Input: str1 = "characters", str2 = "alphabets" 
Output: b c l p r
Input: str1 = "geeksforgeeks", str2 = "geeksquiz" 
Output: f i o q r u z

To solve this problem, we will use the following approach.

Method - 1: Naïve Approach

In this approach, we will use the two loops to check the 1^st string character present in the 2^nd string and vice-versa.

Note - The output string must be in the sorted format.

Let's understand the following algorithm for the naïve approach.

Algorithm

First, we will get the two strings str1 and str2 as input.
Then, we define an empty list uncommon_chars to store the uncommon characters.
Now, traverse str1 and check if a character is present in str2.
Then, check if the character is not present in the str2 and not already added to the uncommon_chars, then add it to uncommon_chars and mark it as used.
Now, traverse the str1 and check if a character present in the str2.
If the character is not present in str1 and not already added to ans, then add it to ans and mark it as used.
Sort the ans string in lexicographical order.
If ans is empty, print -1. Otherwise, print the contents of ans.

Let's understand the below code.

Example -

def find_uncommon_characters(str1, str2):
    uncommon_chars = []

    # Iterate over each character in str1
    for char in str1:
        if char not in str2 and char not in uncommon_chars:
            uncommon_chars.append(char)

    # Iterate over each character in str2
    for char in str2:
        if char not in str1 and char not in uncommon_chars:
            uncommon_chars.append(char)

    return uncommon_chars


# Example usage
string1 = "hello"
string2 = "world"
uncommon_characters = find_uncommon_characters(string1, string2)
result = "".join(sorted(uncommon_characters))
print("Uncommon characters:", result)

Output:

Uncommon characters: dehrw

Explanation -

In the above code, we initialize an empty list of uncommon_chars to store the uncommon characters found. We then iterate over each character in str1 and check if it is not present in str2 and also not already present in uncommon_chars. If both conditions are satisfied, we add the character to uncommon_chars. Similarly, we iterate over each character in str2 and perform the same check.

Finally, we return the list of uncommon_chars that contains all the unique characters that are present in either str1 or str2, but not in both.

The time complexity of this approach is O(n²) since we are using nested loops. It may not be efficient for the larger string.

We can optimize the above solution. Let's understand another method.

Method - 2: Using Hashing

In this approach, we will define an empty dictionary and count the frequency of characters. Once we get the frequency of each character, we find the character whose frequency is equal to 1 and append it to the list. Let's understand the following example.

Example -

def find_uncommon_characters(str1, str2):
    char_freq = {}

    # Count the frequency of characters in str1
    for char in str1:
        char_freq[char] = char_freq.get(char, 0) + 1
        
    print(char_freq)

    # Count the frequency of characters in str2 and update char_freq
    for char in str2:
        char_freq[char] = char_freq.get(char, 0) + 1
    

    uncommon_chars = []

    
    # Find the characters with frequency 1 in char_freq
    for char, freq in char_freq.items():
        if freq == 1:
            uncommon_chars.append(char)
            
    result = "".join(sorted(uncommon_chars))

    return result
# Example usage
str1 = "hello"
str2 = "world"
uncommon_characters = find_uncommon_characters(string1, string2)
print("Uncommon characters:", uncommon_characters)

Output:

Uncommon characters: dehrw

Explanation -

In the above code, we use a dictionary char_freq to store the frequency of characters in both str1 and str2. We iterate over each character in str1 and update the frequency count in char_freq. Then, we iterate over each character in str2 and update the frequency count accordingly.

After counting the frequencies, we create an empty list uncommon_chars to store the uncommon characters. We iterate over the key-value pairs in char_freq and check if the frequency is 1. If so, it means the character is unique to either str1 or str2, and we add it to uncommon_chars.

Finally, we return uncommon_chars containing the uncommon characters found in the two strings.

This time complexity of the above code is O(n) where n is the total number of characters in both str1 and str2.

Method - 3: Map-based Technique

Let's understand the following example.

Example -

def uncommon_chars(a, b) :
    # Initialize two arrays of size 26 to represent the occurrence of characters
    mp1 = [0] * 26
    mp2 = [0] * 26

    # Iterate over string a and mark the occurrence of each character in mp1
    for char in a:
        mp1[ord(char) - ord('a')] = 1

    # Iterate over string b and mark the occurrence of each character in mp2
    for char in b:
        mp2[ord(char) - ord('a')] = 1

    # Store the uncommon characters in the chars string
    chars = ""

    # Compare the occurrence of characters in mp1 and mp2
    for i in range(26):
        if mp1[i] ^ mp2[i]:
            chars += chr(i + ord('a'))

    # Check if there are any uncommon characters found
    if chars == "":
        return "-1"
    else:
        return chars
a = "capital"
b = "country"
result = uncommon_chars(a, b)
print(result)

Output:

ailnopruy

Explanation -

In the above code, we define the function uncommon_chars() takes two string parameters a and b and returns a string containing the uncommon characters between the two strings.

Then we initialize the two arrays mp1 and mp2 of size 26. These arrays represent the occurrence of characters in the strings a and b, respectively. The arrays are initially filled with zeros.

The first loop iterates over each character char in string a and marks the occurrence of that character by setting the corresponding element in mp1 to 1. The mapping is done based on the character's ASCII value, subtracting the ASCII value of 'a' from it to get the corresponding index in the array.

Similarly, the second loop iterates over each character char in string b and marks the occurrence of that character by setting the corresponding element in mp2 to An empty string chars is initialized to store the uncommon characters found. The next loop iterates over the range of 26, representing the 26 characters of the English alphabet.

Within this loop, the condition mp1[i] ^ mp2[i] checks if the occurrence of the character at index i differs between mp1 and mp2. If the condition is true, it means the character is either present in a or b, but not both.

If the condition is satisfied, the character corresponding to the index i is appended to the chars string using the chr function and the ASCII value calculation.

After the loop, the code checks if chars is still an empty string. If it is, there were no uncommon characters found, so the function returns "-1". Otherwise, it returns the chars string containing the uncommon characters.

Finally, the function is called with the strings "capital" and "country", and the returned result is printed.

Method - 4: Using Set

In this approach, we will convert the given string into the set and find the symmetric difference between them. Let's understand the following example.

Example -

str1 = "characters"
str2 = "alphabets"
# Converting both the string
# into sets
str1 = set(str1)
str2 = set(str2)
# Using symmetric difference operator
print("".join(sorted(str1 ^ str2)))
# using symmetric_difference() method
print("".join(sorted(str1.symmetric_difference(str2))))

Output:

bclpr
bclpr

Explanation -

The above code converts the strings into sets, finds the symmetric difference between the sets to obtain the uncommon characters, and then sorts and joins the characters to form a sorted string of uncommon characters.

Next TopicWrite Python Program to Recursively Remove All Adjacent Duplicates

← prev next →