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).

Based on: http://oj.leetcode.com/problems/two-sum/

example:

twoSum [1, 2, 3] 4 === (0, 2)

my solution:

import java.util.HashMap;
import java.util.Scanner;
import java.util.Map;

class TwoSum {
    
    private static int[] findTwoSum(int[] nums, int target) {
        Map<Integer, Integer> numMap = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (numMap.containsKey(complement)) {
                return new int[] { numMap.get(complement), i };
            } else {
                numMap.put(nums[i], i);
            }
        }
        return new int[] {};
    }
}

best kata practice:

import java.util.HashMap;
import java.util.Map;

public class Solution {
  public static int[] twoSum(int[] numbers, int target) {
    Map<Integer, Integer> numToIndexMapping = new HashMap<>(numbers.length);
    for(int i = 0; i < numbers.length; i++) {
      if(numToIndexMapping.containsKey(target - numbers[i])) {
        return new int[] { i, numToIndexMapping.get(target - numbers[i]) };
      } else {
        numToIndexMapping.put(numbers[i], i);
      }
    }
    return new int[0];
  }
}