how to sum two numbers in a list?

This function iterates through all the numbers in the list and finds the sum with other numbers. If the sum is equal to the target, it returns the indices

def indices_sum(nums,target):
    for i in range(len(nums)):
        for j in range(i+1,len(nums)):
            if nums[i]+nums[j] == target: return(i,j)

This question has 2 parts:

1. Retrieving the 2 items in a list which equate to the target

2. Retrieving their index value

   def get_index_for_target(nums, target):

   for x in nums:
       for y in nums:
           if x + y == target:
               return (nums.index(x), nums.index(y))
   

The main problem with solutions testing all possible couples (with imbricated loops or itertools.combinations) is that that are O(n^2), as you basically test all possible combinations of two elements among n (there are n*(n-1)/2 such combinations) until you find a valid one.

When n is large, you will need a more efficient algorithm. One possibility is to first sort the list (this is O(n * log(n))), finding the solution can then be done directly in O(n), which gives you a solution in O(n * log(n)).

We sort the list first, then add the first (smallest) and last (greatest) values. If the sum is too large, we can remove the largest value. If it’s too small, we remove the smallest one, until we reach the exact sum.

We can use a collection.deque to efficiently remove values at any end of the list.

In order to retrieve the indices, we keep them besides the values in tuples.

from collections import deque


def find_target(values, target):

    dq = deque(sorted([(val, idx) for idx, val in enumerate(values)]))

    while True:
        if len(dq) < 2:
            raise ValueError('No match found')

        s =  dq[0][0] + dq[-1][0]

        if s > target:
            dq.pop()
        elif s < target:
            dq.popleft()  
        else:
            break
    return dq[0], dq[-1]



values = [23, 5, 55, 11, 2, 12, 26, 16]
target = 27

sol = find_target(values, target)

print(sol)
# ((11, 3), (16, 7))
# 11 + 16 == 27, indices 3 and 7

print(sol[0][1], sol[1][1])
# 3 7

For each entry in the list, check whether there’s any other numbers in the list after that number that add up to the target. Since a+b = target is equivalent to b = target – a, you can just take each element, look at all the numbers after that element, and check whether they are target – element. If so, return the indices.

for index,num in  enumerate(nums):
    if target-num in nums[index+1:]:
        return(index, nums.index(target-num))

We can use to pointers, at the beginning and at the end of the list to check each index by the sum of the two numbers, looping once.

def sumOfTwo(array, target):
    i = 0
    j = len(array) - 1
    while i < j:
      add = array[i] + array[j]
      if add == target:
        return True
      elif add < target:
        i += 1
      else:
        j -= 1
    return False 

input -> [1, 2, 3, 4] -> target: 6

 i->    <-j
[1][2][3][4]  if i + j = target return True 
              if i + j < target increase i
              else decrease j

Note: In a edge case, a guard of check before the loop, in case: target is a negative value, list is empty, target is null.

We can do the following:

numbers = [2, 7, 11, 15]
target =9
for x in numbers:
    for y in numbers:
        if x+y==target:
            print(x,y)

def indices_sum(nums,target):
    for i in range(0,len(nums)):
        for j in range(i+1,len(nums)):
            if nums[i]+nums[j] == target: 
                print(nums[i],nums[j])
nums=[1,2,3,4,5]
target=5
indices_sum(nums,target)

Either of following approaches can be used to finding two numbers numbers in a list that add up to a given target value:

number_range = [1184.27, 1283.89, 3987.02, 6012.98, 5678.75, 9897.77]

target = 10000

1. Using for loop:

for a in number_range:
for b in number_range[number_range.index(a):]:
if a + b == target:
print(a,b)

Output:
3987.02 6012.98

2. Using itertools.combinations

itertools.combinations(iterable, r)

This approach combines the list items into unique groups of r (here 2), and check if the sum matches the target.

import itertools

for numbers in itertools.combinations(number_range,2):
if sum(numbers) == target:
print(numbers)

Output:
(3987.02, 6012.98)

I haven’t seen any of these solutions solve for list = [3,3,11,15]
target = 6. Unless I missed it. 🙂 The indices don’t return correctly. [0,0] is returned instead of [0,1]

nums = [2, 7, 11, 15]
print(nums[0]+nums[1])