CODEWITHSUNDEEP
pythonlist
Richard
Richard

Reputation: 85

Find the 1 based position to which two lists are the same

The challange is to write a function to compare two rather small lists of integers (mostly less than 10 elements each). One list could be something like:

self = [0, 0, 1, 2]

The lists which it is to be compared with could look like one of the following examples:

other1 = []
other2 = [0, 0, 1]
other3 = [0, 0, 1, 2, 0]
other4 = [0, 1, 1, 2]
other5 = something

As you can see, duplicate elements are quite common and the order of elements is important.

The expected result should be an integer, representing how long self and other are the same, counted from the beginning. So depending on other, the result would be:

result1 = 0
result2 = 3
result3 = 4
result4 = 1
result5 = 0

The code should be most efficient, since it is to be used some 100 times for every user interaction.

I coded the following, it works as desired, but seems to be kind of slow:

def match(self, other):
    if self == other:
        return len(self)
    element = -1
    for element in range(min(len(self),  len(other))):
        if self[element] != other[element]:
            element -= 1
            break
    return element +1

The first if statement is already an enhancement to speed things up, but the solution still seems slow and also looks a bit clumsy with all its corrections to the variable named element and the two return statements.

Has anybody a name for such a function which is better than 'match' or 'compare'?

Upvotes: 3

Views: 260

Answers (3)

Gareth Latty
Gareth Latty

Reputation: 88977

In a related question, I posted the following potential solutions:

def while_equal(seq, other):
    for this, that in zip(seq, other):
        if this != that:
            return
        yield this

def match(seq, other):
    return sum(1 for _ in while_equal(seq, other))

and 

def match_loop(seq, other):
    count = 0
    for this, that in zip(seq, other):
        if this != that:
            return count
        count += 1
    return count

These versions are both faster than the other given solutions (the second being the fastest), and, I would argue, more readable.

Upvotes: 1

aga
aga

Reputation: 29416

Edit: as jamylak pointed out, mine solution is wrong. I'll keep it here so everyone who wants to answer this question will see the whole problem, not just first two cases.

Yet another solution which doesn't require itertools, though it'll be not as efficient as jamylak's solution.

def compareLists(list1, list2):
    return sum(map(lambda (x,y): 1 if x == y else 0, zip(list1, list2)))

Upvotes: 0

jamylak
jamylak

Reputation: 133544

>>> from itertools import takewhile, izip
>>> def F(seq1, seq2):
        return sum(1 for x in takewhile(lambda x: x[0] == x[1], izip(seq1, seq2)))

>>> F([0, 0, 1, 2], [0, 0, 1, 2, 0])
4

Upvotes: 4

Related Questions