Как сложить два числа в списке?

Эта функция перебирает все числа в списке и находит сумму с другими числами. Если сумма равна цели, возвращает индексы

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)

используйте itertools.combinations, который объединяет элементы вашего списка в неповторяющиеся пары и проверяет, совпадает ли сумма. Если это так, распечатайте позиции терминов:

import itertools

integer_array = [2, 8, 4, 7, 9, 5, 1]
target = 10
for numbers in itertools.combinations(integer_array,2):
    if sum(numbers) == target:
        print([integer_array.index(number) for number in numbers])

Этот вопрос состоит из 2 частей:

1. Получение 2 элементов в списке, которые соответствуют цели

2. Получение значения их индекса

   def get_index_for_target (числа, цель):

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

Основная проблема с решениями, тестирующими все возможные пары (с составными петлями или itertools.combinations), заключается в том, что это O (n ^ 2), поскольку вы в основном тестируете все возможные комбинации двух элементов среди n (есть n * (n-1) / 2 таких комбинации), пока не найдете подходящую.

Когда n велико, вам понадобится более эффективный алгоритм. Одна из возможностей - сначала отсортировать список (это O (n * log (n))), затем поиск решения может быть выполнен непосредственно в O (n), что дает вам решение в O (n * log (n) ).

Сначала мы сортируем список, затем добавляем первое (наименьшее) и последнее (наибольшее) значения. Если сумма слишком велика, мы можем удалить наибольшее значение. Если он слишком мал, мы удаляем самый маленький, пока не дойдем до точной суммы.

Мы можем использовать collection.deque для эффективного удаления значений в любом конце списка.

Чтобы получить индексы, мы сохраняем их помимо значений в кортежах.

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

Для каждой записи в списке проверьте, есть ли в списке какие-либо другие числа после этого числа, которые в сумме соответствуют цели. Поскольку a + b = target эквивалентно b = target - a, вы можете просто взять каждый элемент, посмотреть все числа после этого элемента и проверить, являются ли они целевым элементом. Если да, верните индексы.

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

Мы можем использовать указатели в начале и в конце списка, чтобы проверять каждый индекс по сумме двух чисел, выполняя цикл один раз.

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

Примечание: В крайнем случае, защита проверки перед циклом, если: цель - отрицательное значение, список пуст, цель - ноль.

Мы можем сделать следующее:

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