两个数字的索引等于目标值

Question

I was trying to solve this problem and I got stuck at the end. This function takes a list consisting of integers and a target value.The indices of any two sum of integers which is equal to the target value should be returned. For Eg: - ([1,2,3],4) should return [0,2] because 3+1=4. My Approach: -

import itertools
import numpy as np
def indices(numbers,target):
    comb_nos = [list(x) for x in itertools.combinations(numbers, 2)]
    print(comb_nos)
    result =np.sum(comb_nos,1)
    print(result)
indices([2,2,3],4)

I managed to get all combinations of the integers in a set of 2(using the itertools module) and use the numpy library to sum it up along an axis of 1. I can't seem to figure out a way to print the indices. The Combination of integers are [[2, 2], [2, 3], [2, 3]] and the sum of those individual lists correspondingly are [4 5 5] . I want to print the indices of 4(Which is the target value)

There are few hints out there but since I have reached almost the ending,I want to know how I could have done it my way.I would appreciate it if anyone could help me solve this.

Answer 1

You can do it without loop by calculating all combinations of pairwise summation of elements using numpy broadcasting and then searching for target using np.argwhere (if your arrays are too large, using itertools might be slightly more efficient as this one calculates every combination twice, however it is faster in the calculations itself):

def indices(numbers,target):
  idx = np.argwhere((numbers.T[:,None]+numbers.T)==target)
  return (idx[idx[:,0]<idx[:,1]])
print(indices(np.array([2,2,3]),4))

And if you want to use itertools, you can do it this way:

def indices(numbers,target):
  idx = np.array(list(itertools.combinations(range(len(numbers)),2)))
  return idx[np.flatnonzero(numbers[np.r_[idx]].sum(1) == target)]
print(indices(np.array([2,2,3]),4))

output:

[[0 1]]

EDIT : explanation: numbers.T[:,None]+numbers.T creates a matrix of summations of all pairwise combinations of numbers . In other words, its [i,j] -th element is numbers[i]+numbers[j] . np.argwhere finds which of those are equal to target .

idx[:,0]<idx[:,1] is a condition to filter upper triangle of matrix, since lower triangle of matrix is the same pairwise combinations of numbers as upper triangle (eg [0,1] vs. [1,0] ).

Answer 2

You can use combinations() from itertools :

from itertools import combinations


def indices(numbers, target):

    return [[f[0] for f in s] for s in combinations(enumerate(numbers),2)if sum([f[1] for f in s])==target]

print(indices([1, 2, 3, 2, 3, 2],6))

Output:

[[2, 4]]

Answer 3

Plain python solution:

def indices(nums: List[int], target: int) -> List[int]:
    for i in range(len(nums)):
        for j in range(i+1, len(nums)):
            if nums[i] + nums[j] == target:
                return [i,j]
            else:
                return "no pair in nums list sums to target"

Answer 4

class Solution { public int[] twoSum(int[] nums, int target) {

    int[] ans = new int[2];
   
   for(int i=0;i<nums.length;i++)
    {
        for(int j=i+1;j<nums.length;j++)
        {
            if(nums[i]+nums[j]==target)
            {
                ans[0]=i;
                ans[1]=j;
                break;
            }
        }
    }
return ans;
    
    
}
    
    public static void main(String args[]){ 
        
        Solution sol = new Solution();
        int[] arr = {1,0,2,4,5};
       int[] ans = sol.twoSum(arr, 7);
       
             
       for (int i=0;i<ans.length;i++) {
          
           System.out.println(ans[i]);
         
           
       }
        
                  
    
}

}