Reviewing LeetCode's first problem： 1. Two Sum.

var twoSum = function(nums, target) {
  const n = nums.length, map = new Map
  for (let i = 0; i < n; i++) {
    if (map.has(nums[i])) return [map.get(nums[i]), i]
    map.set(target - nums[i], i)
  }
};

function twoSum(nums: number[], target: number): number[] {
  const n = nums.length, map = new Map
  for (let i  = 0; i < n; i++) {
    if (map.has(nums[i])) return [map.get(nums[i]), i]
    map.set(target - nums[i], i)
  }
};

func twoSum(nums []int, target int) []int {
  m := map[int]int{}
  for i, num := range nums {
    if _, ok := m[num]; ok {
      return []int{m[num], i}
    }
    m[target - num] = i
  }
  return []int{}
}

class Solution {
  function twoSum($nums, $target) {
    $map = array();
    foreach ($nums as $i => $num) {
      if ($map[$num] !== null) return [$map[$num], $i];
      $map[$target - $num] = $i; 
    }
  }
}

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

public class Solution {
  public int[] TwoSum(int[] nums, int target) {
    Dictionary<int, int> map = new Dictionary<int, int>();
    int n = nums.Length;
    for (int i = 0; i < n; i++) {
      if (map.ContainsKey(nums[i])) return new int[]{map[nums[i]], i};
      map[target - nums[i]] = i;
    }
    return new int[]{};
  }
}

class Solution {
public:
  vector<int> twoSum(vector<int>& nums, int target) {
    unordered_map<int, int> map;
    int n = nums.size();
    vector<int> ans(2, 0);
    for (int i = 0; i < n; i++) {
      if (map.count(nums[i]) == 1) {
        ans[0] = map[nums[i]], ans[1] = i;
        return ans;
      }
      map.emplace(target - nums[i], i);
    }
    return ans;
  }
};

typedef struct {
  int key;
  int val;
  UT_hash_handle hh;
} HashItem;
void freeMap(HashItem** map) {
  HashItem *cur, *tmp;
  HASH_ITER(hh, *map, cur, tmp) {
    HASH_DEL(*map, cur);
    free(cur);
  }
}
int* twoSum(int* nums, int numsSize, int target, int* returnSize){
  HashItem* map = NULL;
  int* ans = malloc(sizeof(int) * 2);
  *returnSize = 2;
  for (int i = 0; i < numsSize; i++) {
    HashItem* pEntry = NULL;
    HASH_FIND_INT(map, &nums[i], pEntry);
    if (pEntry != NULL) {
      ans[0] = pEntry->val;
      ans[1] = i;
      freeMap(&map);
      return ans;
    }
    pEntry = malloc(sizeof(HashItem));
    pEntry->key = target - nums[i];
    pEntry->val = i;
    HASH_ADD_INT(map, key, pEntry);
  }
  freeMap(&map);
  return ans;
}

class Solution:
  def twoSum(self, nums: List[int], target: int) -> List[int]:
    m = dict()
    for i, num in enumerate(nums):
      if num in m: return [m[num], i]
      m[target - num] = i