查找 python 中的所有反向对

Question

Define the function rev_pair(slist), whose argument is a list and all elements of the list are strings. This function returns another list, and all elements of the returned list are a tuple of two strings from slist, and inverted from each other. The string that appears first in slist is on the left side of this tuple, and the one that appears later is on the right side. The tuple of strings that appear first in slist on the left appears first in the list of returned values, and the same strings appear only once in the returned values.

All characters in the string are either case alphabet or 0 to 9.

[example]

input : ['abc', 'ded', 'cba', 'ffa']

output : [('abc', 'cba'), ('ded', 'ded')]

here is my code but still Wrong Answer

def rev_pair(slist):
    def isrev(s1,s2):
        if s2[::-1] == s1:
            return True
        else:
            return False
    res = []
    for i in range(len(slist)):
        for u in range(i, len(slist)):
            if isrev(slist[i], slist[u]):
                if not (slist[i], slist[u]) in res:
                    res.append((slist[i], slist[u]))
                    break
    return res
slist = []
exec('slist=' + input())
print(rev_pair(slist))

Answer 1

Here's a short version of what you are trying to achieve:

def revevers_list(l):
    new_l = []
    for item in l:
        if len(item) == len(set(item)):
            new_l.append((item, item[::-1]))
    return new_l

slist = input().split(",")
print(revevers_list(slist))

Test result:

>> python app.py
abc, def, ddt
[('abc', 'cba'), (' def', 'fed ')]

Answer 2

try something like this

def rev_pair(input_list):
    """
    Function that checks coincidence between input list elements and reversed string of element in same list.
    """
    output = []
    for string in input_list:
        reversed_string = string[::-1]
        for string_ in INPUT:
            if reversed_string == string_:
                output.extend([(string, reversed_string)])
    return output

out = rev_pair(input_list = ['abc', 'ded', 'cba', 'ffa'])
out

results in

[('abc', 'cba'), ('ded', 'ded'), ('cba', 'abc')]

Answer 3

I think this version is a bit more pythonic:

def find_reversed_pairs(data):
    values_count = dict()

    for value in data:
        reversed_value = value[::-1]
        values_count[value] = values_count.get(value, 0) + 1
        if reversed_value in values_count:
            values_count[reversed_value] = values_count.get(reversed_value, 0) + 1

    return [(val, val[::-1]) for val, count in values_count.items() if count >= 2]

Here's a sample output:

['abc', 'def', 'cba', 'ffa', 'fed'] => [('abc', 'cba'), ('def', 'fed')]
['abc', 'ded', 'cba', 'ffa'] => [('abc', 'cba'), ('ded', 'ded')]

Answer 4

The problems all come from the requirement for uniqueness:

Define the function rev_pair(slist), whose argument is a list and all elements of the list are strings. This function returns another list, and all elements of the returned list are a tuple of two strings from slist, and inverted from each other. The string that appears first in slist is on the left side of this tuple, and the one that appears later is on the right side. The tuple of strings that appear first in slist on the left appears first in the list of returned values, and the same strings appear only once in the returned values.

In my code, if the input is ['abc','cba','cba','abc'] , the output would be [('abc','cba'), ('cba', abc')] which is wrong according to the requirement. Then simply remove the second tuple can solve this problem.

Here is the new code.(Not efficient still)

def rev_pair(slist):
    def isrev(s1,s2):
        if s2[::-1] == s1:
            return True
        else:
            return False
    res = []
    for i in range(len(slist)):
        for u in range(i, len(slist)):
            if isrev(slist[i], slist[u]):
                if (slist[i], slist[u]) in res or (slist[u], slist[i]) in res:  # new modification
                    continue
                else:
                    res.append((slist[i], slist[u]))
                    break
    return res


slist = []
exec('slist=' + input())
print(rev_pair(slist))