Python program to count the pairs of reverse strings

Given the String list, write a Python program to count pairs of reverse strings.

Examples:

Input : test_list = ["geeks", "best", "tseb", "for", "skeeg"] 
Output : 2 
Explanation : geeks, skeeg and best, tseb are 2 pairs of reverse strings available.

Input : test_list = ["geeks", "best", "for", "skeeg"] 
Output : 1 
Explanation : geeks, skeeg is 1 pair of reverse strings available.

Method #1 : Using reversed() + loop

In this, we perform task of comparing strings to reversed versions of it using reversed() and conditional statements. In this, loop is used for task of comparing with each string for pairing.

# Python3 code to demonstrate working of
# Reversed Pairs in Strings List
# Using reversed() + loop

# initializing Matrix
test_list = ["geeks", "best", "tseb", "for", "skeeg"]

# printing original list
print("The original list is : " + str(test_list))

res = 0
for idx in range(0, len(test_list)):

    # nested loop to check with each element with possible reverse counterpart
    for idxn in range(idx, len(test_list)):
        if test_list[idxn] == str(''.join(list(reversed(test_list[idx])))):
            res += 1

# printing result
print("Reversed Pairs : " + str(res))

The original list is : ['geeks', 'best', 'tseb', 'for', 'skeeg']
Reversed Pairs : 2

Output:

The original list is : ['geeks', 'best', 'tseb', 'for', 'skeeg'] Reversed Pairs : 2

Time Complexity: O(n*n)
Auxiliary Space: O(n)

Method #2 : Using list comprehension + sum()

In this, list comprehension handles nested loop and sum() handles part of increment counter for counting pairs.

# Python3 code to demonstrate working of
# Reversed Pairs in Strings List
# Using list comprehension + sum()

# initializing Matrix
test_list = ["geeks", "best", "tseb", "for", "skeeg"]

# printing original list
print("The original list is : " + str(test_list))

# list comprehension for nested loop
# sum increments counts
res = sum([1 for idx in range(0, len(test_list)) for idxn in range(idx, len(
    test_list)) if test_list[idxn] == str(''.join(list(reversed(test_list[idx]))))])

# printing result
print("Reversed Pairs : " + str(res))

The original list is : ['geeks', 'best', 'tseb', 'for', 'skeeg']
Reversed Pairs : 2

Output:

The original list is : ['geeks', 'best', 'tseb', 'for', 'skeeg'] Reversed Pairs : 2

Time Complexity: O(n²)
Auxiliary Space: O(n)

Approach 3: Using hashmap (dictionary)

The given code is using a hashmap (dictionary) to count the pairs of reverse strings in a given list of strings. The approach works as follows:

1. Initialize an empty hashmap (dictionary) and a variable to count the number of pairs.
2. Loop through each word in the list of strings.
3. Reverse the current word.
4. Check if the reversed word already exists in the hashmap.
5. If it exists, increment the count of pairs.
6. Add the current word to the hashmap.
7. Print the count of pairs.

# Python3 code to demonstrate working of
# Reversed Pairs in Strings List
# Using hashmap (dictionary)

# initializing list
test_list = ["geeks", "best", "tseb", "for", "skeeg"]

# printing original list
print("The original list is : " + str(test_list))

# initializing hashmap (dictionary)
hashmap = {}
res = 0

# loop to store reversed string of each string in hashmap
cnt = 0

for word in test_list:
    rev_word = word[::-1]

    if rev_word in hashmap:
        cnt+=1
    
    if not word in hashmap:
        hashmap[word] = 1

# printing result
print("Reversed Pairs : " + str(cnt))

The original list is : ['geeks', 'best', 'tseb', 'for', 'skeeg']
Reversed Pairs : 2

Time complexity: O(n), where n is the number of words in the list. This is because the loop iterates through each word once, and each dictionary operation (inserting a key-value pair or checking if a key exists) takes constant time on average. The space complexity of this approach is also O(n), since the hashmap can contain at most n key-value pairs.

The approach is justified because it is simple and efficient for the problem at hand. It avoids the need for nested loops or sorting the list, both of which would result in higher time complexity. The use of a hashmap also allows for constant-time lookup of keys, making it a good choice for this problem.

Approach 5: Using sets

Stepwise Approach:

1. Initialize a variable count to 0 to count the reversed pairs.
2. Initialize an empty set.
3. Loop through each word in the list and for each word:
   a. Get the reversed version of the current word.
   b. Check if the reversed version is in the set.
   c. If the reversed version is in the set, increment the count variable.
   d. Add the current word to the set.
4. Print the count variable as the result.

# Python3 code to demonstrate working of
# Reversed Pairs in Strings List
# Using sets

# initializing list
test_list = ["geeks", "best", "tseb", "for", "skeeg"]

# printing original list
print("The original list is : " + str(test_list))

# initializing set and cnt variable
seen = set()
cnt = 0

# Looping through each word in the list
for word in test_list:
  
    # get the reversed version of the current word
    rev_word = word[::-1]
    
    # check if the reversed version is in the set
    if rev_word in seen:
        cnt += 1
    # add the current word to the set
    seen.add(word)

# printing result
print("Reversed Pairs : " + str(cnt))

The original list is : ['geeks', 'best', 'tseb', 'for', 'skeeg']
Reversed Pairs : 2

Time complexity: O(n), where n is the length of the input list since we loop through the list once.
Auxiliary space: O(n), where n is the length of the input list since we need to store each word in the set.

Method 5: using a two-pointer approach

# Python3 code to find reversed pairs in a list of strings

# Initializing list
test_list = ["geeks", "best", "tseb", "for", "skeeg"]

# Printing original list
print("The original list is: " + str(test_list))

# initializing count variable
cnt = 0

# Looping through each word in the list
for i in range(len(test_list)):
    word = test_list[i]
    rev_word = word[::-1]

    # compare the reversed word with the subsequent words in the list
    for j in range(i+1, len(test_list)):
        if rev_word == test_list[j]:
            cnt += 1

# printing result
print("Reversed Pairs: " + str(cnt))

The original list is: ['geeks', 'best', 'tseb', 'for', 'skeeg']
Reversed Pairs: 2

Time complexity: O(n^2), where n is the number of words in the list. 
Auxiliary space: O(1) because it uses a constant amount of extra space. 

manjeet_04

Follow

Improve

Article Tags :

• Python
• Python Programs
• Python list-programs
• Python string-programs

Practice Tags :

• python