Question

我要解决以下问题-给定整数数组，返回两个数字的索引，这样它们加起来便成为特定的目标。

我将以下数组作为输入-[2，7，11，15]，目标= 9。

因为nums [0] + nums [1] = 2 + 7 = 9，返回[0，1]。

这是我的代码-

import java.util.Random;

public class TwoSum {

    static int[] numbers = new int[] {2, 7, 11, 15};
    int[] indices = new int[numbers.length];

    public static int[] returnIndices(int target, int[] inputArr) {
        int[] indices = new int[2];
        int randomOne = new Random().nextInt(inputArr.length);
        int randomTwo = new Random().nextInt(inputArr.length);
        while(true) {
            if(target == inputArr[randomOne] + inputArr[randomTwo]) {
                indices[0] = randomOne;
                indices[1] = randomTwo;
                break;
            }
        }
        System.out.println("done");
        return indices;
    }

    public static void main(String[] args) {
        int[] output = returnIndices(9, numbers);
    }

}

这不是解决我的问题的正确方法吗？请帮忙。

Answer 1

您可以通过以下方式使用哈希图存储第一个数组：

   key  value(index in array)
    2 - 0
    7 - 1
    11 - 2
    15 - 3

接下来，获取目标元素9，并从索引0开始遍历给定数组。

索引0处的元素为2->计算（9-2）= 7->检查7是否为哈希图中的键

其他说明：您需要注意以下情况：

arr = [3，2，1，1]目标= 6（在这种情况下不存在答案，但是通过上述方法，当您计算6-3 = 3时，将得到索引0作为答案。）

但是可以很容易地通过检查（target-arr [i] == arr [i]）返回true来解决。如果返回true，并且哈希表在键arr [i]上存储了两个索引，则将其作为答案返回，否则继续下一个元素。

Answer 2

有多种方法可以解决此问题：

哈希图方式-@mettleap answer涵盖了那个。
排序数组方式-我将向您解释其伪代码。

让我们举个例子来看一下它的实际作用。我们在数组中获得了arr = [5, 2, 1, 9, 7]个元素，如果可以制作8，我们将找到两个元素的索引。

如果仔细观察，就会知道如果我们对数组中的第3个元素和最后一个元素求和，我们将得到8，这意味着2和4是我们的答案。 那么那里会有土地吗？ 让我们一步一步走

维护一个具有相同大小的单独数组，它将在初始设置中保存arr的索引。
```
[5, 2, 1, 9, 7] = arr
[0, 1, 2, 3, 4] = index_arr
```
现在按升序对arr进行排序，并对index_arr进行排序，以使arr中元素的索引在其初始设置中仍然存在。
```
[1, 2, 5, 7, 9] = arr
[2, 1, 0, 4, 3] = index_arr
```

使用下面的伪代码：

low  = 0
high = length of arr - 1

while (low < high) {
    sum = arr[low] + arr[high]

    if (sum  == number) {}
        print "index_arr[low]" and "index_arr[high]" 
        break the loop and exit
    } else if ( sum < number ) {
        low = low + 1
    } else {
        high = high - 1
    }
}

让我们看看实际的伪代码：

[1, 2, 5, 7, 9] = arr
[2, 1, 0, 4, 3] = index_arr

Iteration # 01
low = 0 and high = 4
sum = arr[0] + arr[4] = 1 + 9 = 10
10 > 8 , means 'else' will be executed high = high - 1 = 4 - 1 = 3

Iteration # 02
low = 0 and high = 3
sum = arr[0] + arr[3] = 1 + 7 = 8
8 == 8 , means first 'if' condiion will execute, and will indices and exit the loop

时间复杂度-O（n）
空间复杂度-O（n）

Answer 3

我已经在c＃中尝试过，可能会有帮助。

class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            int[] nums = { 2, 7, 11, 15 };
            int target = 9;
            int[] result= TwoSumNumbers(nums, target);
        }

        public static int[] TwoSumNumbers(int[] nums, int target)
        {
            Dictionary<int, int> numsDict = new Dictionary<int, int>();

            for (int i = 0; i < nums.Length; i++)
            {
                int num = nums[i];

                if (numsDict.TryGetValue(target - num, out int index))
                {
                    return new[] { index, i };
                }

                numsDict[num] = i;
            }

            return null;
        }
    }

Answer 4

class Solution {
public int[] twoSum(int[] nums, int target) {
    int [] answer = new int[2];
    Map<Integer,Integer> values = new HashMap<Integer,Integer>();
    for ( int i=0; i < nums.length; i++){
        values.put(nums[i],i);
    }
    for ( int i=0; i < nums.length; i++){
        int val = target - nums[i];
        Integer secondIndex = values.get(val);
        if ( secondIndex != null && secondIndex != i){
            answer[0] = i;
            answer[1] = secondIndex;
            return answer;
        }
    }
    return answer;
}

}

Answer 5

C＃版本

        using System;
        using System.Collections.Generic;
        using System.Text;
        using System.Linq;

        namespace MyBasics
        {
            class ArrayIndexForTarget
            {
                public static void Main()
                {
                    ArrayIndexForTarget find = new ArrayIndexForTarget();
                    int[] arr = new int[] { 9, 2, 3, 9, 10 };
                    int target = 11;
                    var result = find.IndexFinder(arr, target);
    
                    Console.ReadKey();
                }
             public  int[]  IndexFinder(int[]myArray,int target)
                {
                    int[] arr = new int[2];
                    Dictionary<int, int> dict = new Dictionary<int, int>();

                    for (int p=0; p < myArray.Length; p++) 
                    {
                        int numberToFind = target - myArray[p];
                        if (dict.ContainsValue(numberToFind))
                        {
                            arr[0] = dict.FirstOrDefault(x => x.Value == numberToFind).Key;
                            arr[1] = p;
                            return arr;
                        }
                        else
                        {
                            dict.Add(p,myArray[p]);
                        }
                    }
                    return arr;

                }
            }
        }

Answer 6

class Solution {
    function twoSum($nums, $target) {        
        $lenght = count($nums);
        $indices = array();
        for($i = 0; $i<$lenght-1; $i++){
            for($j=$i+1; $j<$lenght; $j++){
                if(($nums[$i]+$nums[$j]) == $target){
                    $indices[] = $i;
                    $indices[] = $j;
                    
                    return $indices;
                }
            }
                
        }
    } }

Answer 7

public class Main {

public static void main(String[] args) {
int [] arr = {4,7,1,-3,2};

    for(int i=0; i<arr.length-1; i++)
    {
        for(int j=0; j<=arr.length-2; j++)
        {
            if((arr[i]+arr[j+1])==6)
            { 
                System.out.println("indices = "+"["+i +","+(j+1)+"]");
            }
        }
     }
  }
}

返回两个数字的索引，以便它们加起来成为一个特定的目标

7 个答案: