Two Sum Indices

import java.util.*;
class Solution {
    public int[] two_sum_indices(int[] nums, int target) {
        Map<Integer, Integer> seen = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int need = target - nums[i];
            if (seen.containsKey(need)) return new int[]{seen.get(need), i};
            seen.put(nums[i], i);
        }
        return new int[]{};
    }
}

function two_sum_indices(nums, target) {
    const seen = {};
    for (let i = 0; i < nums.length; i++) {
        const need = target - nums[i];
        if (seen[need] !== undefined) return [seen[need], i];
        seen[nums[i]] = i;
    }
    return [];
}

<?php
function two_sum_indices($nums, $target) {
    $seen = [];
    foreach ($nums as $i => $x) {
        $need = $target - $x;
        if (isset($seen[(string)$need])) return [$seen[(string)$need], $i];
        $seen[(string)$x] = $i;
    }
    return [];
}
?>

from typing import List

def two_sum_indices(nums: List[int], target: int) -> List[int]:
    seen = {}
    for i, x in enumerate(nums):
        need = target - x
        if need in seen:
            return [seen[need], i]
        seen[x] = i
    return []

use std::collections::HashMap;
fn two_sum_indices(nums: Vec<i32>, target: i32) -> Vec<i32> {
    let mut seen: HashMap<i32, i32> = HashMap::new();
    for (i, x) in nums.iter().enumerate() {
        let need = target - *x;
        if let Some(j) = seen.get(&need) {
            return vec![*j, i as i32];
        }
        seen.insert(*x, i as i32);
    }
    vec![]
}

function two_sum_indices(nums: number[], target: number): number[] {
    var seen: { [key: string]: number } = {};
    for (var i = 0; i < nums.length; i++) {
        var need = target - nums[i];
        var key = String(need);
        if (seen[key] !== undefined) return [seen[key], i];
        seen[String(nums[i])] = i;
    }
    return [];
}