public static int[] twoSum(int[] numbers, int target) {
    int[] ret = new int[2];
    for (int i = 0; i  

class Pair implements Comparable{
    public int number;
    public int idx;
    public Pair(int number, int idx){
        this.number = number;
        this.idx = idx;
    }
    public int compareTo(Pair other){
        return this.number - other.number;
    }
}
public class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int n = numbers.length;
        Pair[] pairs = new Pair[n];
        for(int i = 0; i  target){
                end--;
            }
            else{
                if(pairs[begin].idx > pairs[end].idx){
                    result[0] = pairs[end].idx;
                    result[1] = pairs[begin].idx;
                }else{
                result[0] = pairs[begin].idx;
                result[1] = pairs[end].idx;
                }
                break;
            }
        }
        return result;
    }
}　　

public class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap m = new HashMap();
        int[] res = new int[2];
        for (int i = 0; i  

public class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap m = new HashMap();
        int[] res = new int[2];
        for (int i = 0; i  

class Solution(object):
    def twoSum(self, nums, target):
        hash_map = {}
        for i, v in enumerate(nums):
            hash_map[v] = i

        for index1, value in enumerate(nums):
            if  target - value in hash_map:
                index2 = hash_map[target - value]
                if index1 != index2:
                    return [index1, index2]　　

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        lookup = {}
        for i, num in enumerate(nums):
            if target - num in lookup:
                return [lookup[target - num], i]
            lookup[num] = i

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        lookup = {}
        for i in range(len(nums)):
            if target - nums[i] in lookup:
                return [lookup[target - nums[i]], i]
            lookup[nums[i]] = i　　

class Solution(object):
    def twoSum(self, nums, target):
        if len(nums) <= 1:
            return False
        buff_dict = {}
        for i in range(len(nums)):
            if nums[i] in buff_dict:
                return [buff_dict[nums[i]], i]
            else:
                buff_dict[target - nums[i]] = i

class Solution {
public:
    vector twoSum(vector& nums, int target) {
        unordered_map lookup;
        for (int i = 0; i