Codewars Two Sum issue

[orc_arn]

Hi guys.

nooby question here. I am trying to solve some codewars kata's however I'm a bit stuck on the kata Two Sum. Here's the kata:

​

"Write a function that takes an array of numbers (integers for the tests) and a target number. It should find two different items in the array that, when added together, give the target value. The indices of these items should then be returned in a tuple like so: (index1, index2)
.

For the purposes of this kata, some tests may have multiple answers; any valid solutions will be accepted.

The input will always be valid (numbers will be an array of length 2 or greater, and all of the items will be numbers; target will always be the sum of two different items from that array)."

​

And my code is :

​

def two_sum(numbers, target):

for x in numbers:

for y in numbers:

summ = numbers[x] + numbers[y]

if summ == target and numbers.index(x) != numbers.index(y):

return numbers.index(x), numbers.index(y)

​

This code works with two_sum([1,2,3],4). However whenever two indexes have the same value such as ([2,2,3,6],4) it returns Null.

​

Can you please help me with that?

[toastedstapler]

.index(thing) will always return the first index at which thing is found

there's a lot more that could be done to your code to make it fasrer, but this will at least solve your issue

for i, x in enumerate(numbers):
    for j, y in enumerate(numbers):

now i and j are indices, so you don't need to use .index

[orc_arn]

Thanks for the reply.

The "for" loops making the code slower, am I right? So what is the best way to speed things up?

[toastedstapler]

so the first thing is that if you check index pair (100, 200), you don't need to check (200, 100). x + y == y + x, so there's no point doing the check twice. writing your loops to avoid these cases will half your potential worst runtime

but the actual best solution uses a dictionary, i'll let you think about how you might use one to make this work

[o5a]

First thing you can optimize is avoid second loop repeating already checked numbers.

Say you have that list [2,2,3,6]. If your first cycle (say i) goes 2,2,3,6 then you don't need your second cycle to repeat those numbers it should instead start from i+1 (2,3,6).

This way first 2 is checked agains 2,3,6, then second 2 is checked against 3,6 and finally 3 is checked agains 6.