Two-Sum with Hash Lookup

Walk the array once, storing seen values in a lookup table. When the complement is already present, the result indices are known.

Algorithm

Basic Implementation

basic.rs

fn main() {
	let arr = [2, 7, 11, 4, 5];
	let target = 9;
	let mut seen = std::collections::HashMap::new();
	let mut result = (-1, -1);
	for (i, value) in arr.iter().enumerate() {
		let need = target - value;
		if let Some(j) = seen.get(&need) {
			result = (*j as i32, i as i32);
			break;
		}
		seen.insert(*value, i);
	}
	println!("[{}, {}]", result.0, result.1);
}

Complexity

Time: O(n) average
Space: O(n)

Implementation notes

The checked source uses a fixed array literal, let arr = [2, 7, 11, 4, 5], not a Vec.
let mut seen = std::collections::HashMap::new() builds a mutable map from copied i32 values to usize indices.
The loop uses arr.iter().enumerate(), so i is a usize and value is a borrowed &i32. Arithmetic target - value relies on Rust's integer subtraction over the referenced scalar.
Lookup happens before insertion: seen.get(&need) returns Option<&usize>. On Some(j), the code copies *j, casts both indices to i32, stores result = (*j as i32, i as i32), and breaks.
On a miss, seen.insert(*value, i) copies the current value into the map. No duplicate update is reached in this trace.
The trace records seen={} at start, then i=0 with need=7 as a miss and seen={2: 0}. At i=1, need=2 hits and records result [0, 1].
println!("[{}, {}]", result.0, result.1) prints the deterministic index pair [0, 1]; the code never iterates over seen, so hash-map iteration order is irrelevant.

execution replay The checked-in replay follows the language-neutral state table for `array-two-sum-hash`.

cross-language comparison This Rust DSA version keeps the same data and final output as every other DSA book in this wave.