Python - Similar characters Strings comparison

Given two Strings, separated by delim, check if both contain same characters.

Input : test_str1 = 'e!e!k!s!g', test_str2 = 'g!e!e!k!s', delim = '!' 
Output : True 
Explanation : Same characters, just diff. positions. 

Input : test_str1 = 'e!e!k!s', test_str2 = 'g!e!e!k!s', delim = '!' 
Output : False 
Explanation : g missing in 1st String.

Method #1 : Using sorted() + split()

In this, we perform split using split(), and then perform the task of sorting to get strings in order, post that strings are compared using the comparison operator.

The original string 1 is : e:e:k:s:g
The original string 2 is : g:e:e:k:s
Are strings similar : True

Time Complexity: O(n) -> (split function)
Auxiliary Space: O(n)

Method #2 : Using set() + split()

In this, instead of sort(), we convert strings to set(), to get ordering. This works only on unique character strings.

The original string 1 is : e:k:s:g
The original string 2 is : g:e:k:s
Are strings similar : True

Time Complexity: O(n) -> (split function)
Auxiliary Space: O(n)

Method #3: Using dictionary

In this approach, we can use dictionaries to count the frequency of each character in both the strings. Then, we can compare the frequency of each character between the two dictionaries to check if the strings have the same characters or not.

Here are the steps:

1. Initialize two dictionaries, one for each string.
2. Split the strings into characters using the delimiter ':' and loop through the characters of each string.
3. For each character, check if it is already present in the dictionary. If it is not present, add it with a value of 1. If it is already present, increment its value by 1.
4. After both dictionaries are created, compare them by looping through each key in one dictionary and checking if the key exists in the other dictionary with the same value. If all keys and values match, return True. Otherwise, return False.
5. Print the result.

The original string 1 is : e:k:s:g
The original string 2 is : g:e:k:s
Are strings similar : True

Time complexity: O(n), where n is the length of the longer string (as we are looping through each character in each string once).
Auxiliary space: O(k), where k is the number of unique characters in both strings (as we are creating dictionaries to store the frequency of each character).

Method 4: using the Counter() function from the collections module. 

This approach involves the following steps:

1. Import the collections module.
2. Initialize the two strings to be compared.
3. Initialize an empty dictionary for each string.
4. Use the Counter() function to count the frequency of each character in both strings and store the results in the corresponding dictionary.
5. Compare the two dictionaries to check if they have the same keys with the same frequency of values.
6. Print the result.

The original string 1 is : e:k:s:g
The original string 2 is : g:e:k:s
Are strings similar : True

Time complexity: The time complexity of this approach is O(n), where n is the length of the longest string. 
Auxiliary space: The auxiliary space required by this approach is O(k), where k is the number of unique characters in both strings. 

Method 5 : Using list comprehension and all()

 step-by-step approach of the code:

1. Initialize two strings: test_str1 and test_str2.
2. Initialize a delimiter as : in delim variable.
3. Split test_str1 and test_str2 strings based on delimiter using the split() method and store the resulting lists in list1 and list2 respectively.
4. Check if all characters in list1 are present in list2 using a list comprehension and the all() function.
5. Similarly, check if all characters in list2 are present in list1.
6. Store the result of the check in a variable called res.
7. Print the result of the comparison by converting the boolean value of res to a string using str() function and concatenating it with the string "Are strings similar : ".

Are strings similar : True

Time complexity: O(n^2) where n is the length of the longer string (due to the all() function in the list comprehension)
Auxiliary space: O(n) where n is the length of the longer string (for the two lists created in memory)